cb7210.c

   1// SPDX-License-Identifier: GPL-2.0
   2
   3/***************************************************************************
   4 * Measurement Computing boards using cb7210.2 and cbi488.2 chips
   5 *    copyright            : (C) 2001, 2002 by Frank Mori Hess
   6 ***************************************************************************/
   7
   8#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   9#define dev_fmt pr_fmt
  10#define DRV_NAME KBUILD_MODNAME
  11
  12#include "cb7210.h"
  13#include <linux/ioport.h>
  14#include <linux/sched.h>
  15#include <linux/module.h>
  16#include <linux/slab.h>
  17#include <asm/dma.h>
  18#include <linux/bitops.h>
  19#include <linux/pci.h>
  20#include <linux/pci_ids.h>
  21#include <linux/string.h>
  22#include <linux/init.h>
  23#include <linux/delay.h>
  24#include "gpib_pci_ids.h"
  25#include "quancom_pci.h"
  26
  27MODULE_LICENSE("GPL");
  28MODULE_DESCRIPTION("GPIB driver Measurement Computing boards using cb7210.2 and cbi488.2");
  29
  30static int cb7210_read(struct gpib_board *board, u8 *buffer, size_t length,
  31		       int *end, size_t *bytes_read);
  32
  33	static inline int have_fifo_word(const struct cb7210_priv *cb_priv)
  34{
  35	if (((cb7210_read_byte(cb_priv, HS_STATUS)) &
  36	     (HS_RX_MSB_NOT_EMPTY | HS_RX_LSB_NOT_EMPTY)) ==
  37	    (HS_RX_MSB_NOT_EMPTY | HS_RX_LSB_NOT_EMPTY))
  38		return 1;
  39	else
  40		return 0;
  41}
  42
  43static inline void input_fifo_enable(struct gpib_board *board, int enable)
  44{
  45	struct cb7210_priv *cb_priv = board->private_data;
  46	struct nec7210_priv *nec_priv = &cb_priv->nec7210_priv;
  47	unsigned long flags;
  48
  49	spin_lock_irqsave(&board->spinlock, flags);
  50
  51	if (enable) {
  52		cb_priv->in_fifo_half_full = 0;
  53		nec7210_set_reg_bits(nec_priv, IMR2, HR_DMAI, 0);
  54
  55		cb7210_write_byte(cb_priv, HS_RX_ENABLE | HS_TX_ENABLE | HS_CLR_SRQ_INT |
  56				  HS_CLR_EOI_EMPTY_INT | HS_CLR_HF_INT | cb_priv->hs_mode_bits,
  57				  HS_MODE);
  58
  59		cb_priv->hs_mode_bits &= ~HS_ENABLE_MASK;
  60		cb7210_write_byte(cb_priv, cb_priv->hs_mode_bits, HS_MODE);
  61
  62		cb7210_write_byte(cb_priv, irq_bits(cb_priv->irq), HS_INT_LEVEL);
  63
  64		cb_priv->hs_mode_bits |= HS_RX_ENABLE;
  65		cb7210_write_byte(cb_priv, cb_priv->hs_mode_bits, HS_MODE);
  66	} else {
  67		nec7210_set_reg_bits(nec_priv, IMR2, HR_DMAI, 0);
  68
  69		cb_priv->hs_mode_bits &= ~HS_ENABLE_MASK;
  70		cb7210_write_byte(cb_priv, cb_priv->hs_mode_bits, nec7210_iobase(cb_priv) +
  71				  HS_MODE);
  72
  73		clear_bit(READ_READY_BN, &nec_priv->state);
  74	}
  75
  76	spin_unlock_irqrestore(&board->spinlock, flags);
  77}
  78
  79static int fifo_read(struct gpib_board *board, struct cb7210_priv *cb_priv, u8 *buffer,
  80		     size_t length, int *end, size_t *bytes_read)
  81{
  82	ssize_t retval = 0;
  83	struct nec7210_priv *nec_priv = &cb_priv->nec7210_priv;
  84	int hs_status;
  85	u16 word;
  86	unsigned long flags;
  87
  88	*bytes_read = 0;
  89	if (cb_priv->fifo_iobase == 0)	{
  90		dev_err(board->gpib_dev, "fifo iobase is zero!\n");
  91		return -EIO;
  92	}
  93	*end = 0;
  94	if (length <= cb7210_fifo_size)	{
  95		dev_err(board->gpib_dev, " bug! fifo read length < fifo size\n");
  96		return -EINVAL;
  97	}
  98
  99	input_fifo_enable(board, 1);
 100
 101	while (*bytes_read + cb7210_fifo_size < length)	{
 102		nec7210_set_reg_bits(nec_priv, IMR2, HR_DMAI, HR_DMAI);
 103
 104		if (wait_event_interruptible(board->wait,
 105					     (cb_priv->in_fifo_half_full &&
 106					      have_fifo_word(cb_priv)) ||
 107					     test_bit(RECEIVED_END_BN, &nec_priv->state) ||
 108					     test_bit(DEV_CLEAR_BN, &nec_priv->state) ||
 109					     test_bit(TIMO_NUM, &board->status))) {
 110			retval = -ERESTARTSYS;
 111			nec7210_set_reg_bits(nec_priv, IMR2, HR_DMAI, 0);
 112			break;
 113		}
 114
 115		spin_lock_irqsave(&board->spinlock, flags);
 116
 117		nec7210_set_reg_bits(nec_priv, IMR2, HR_DMAI, 0);
 118
 119		while (have_fifo_word(cb_priv))	{
 120			word = inw(cb_priv->fifo_iobase + DIR);
 121			buffer[(*bytes_read)++] = word & 0xff;
 122			buffer[(*bytes_read)++] = (word >> 8) & 0xff;
 123		}
 124
 125		cb_priv->in_fifo_half_full = 0;
 126
 127		hs_status = cb7210_read_byte(cb_priv, HS_STATUS);
 128
 129		spin_unlock_irqrestore(&board->spinlock, flags);
 130
 131		if (test_and_clear_bit(RECEIVED_END_BN, &nec_priv->state)) {
 132			*end = 1;
 133			break;
 134		}
 135		if (hs_status & HS_FIFO_FULL)
 136			break;
 137		if (test_bit(TIMO_NUM, &board->status))	{
 138			retval = -ETIMEDOUT;
 139			break;
 140		}
 141		if (test_bit(DEV_CLEAR_BN, &nec_priv->state)) {
 142			retval = -EINTR;
 143			break;
 144		}
 145	}
 146	hs_status = cb7210_read_byte(cb_priv, HS_STATUS);
 147	if (hs_status & HS_RX_LSB_NOT_EMPTY) {
 148		word = inw(cb_priv->fifo_iobase + DIR);
 149		buffer[(*bytes_read)++] = word & 0xff;
 150	}
 151
 152	input_fifo_enable(board, 0);
 153
 154	if (wait_event_interruptible(board->wait,
 155				     test_bit(READ_READY_BN, &nec_priv->state) ||
 156				     test_bit(RECEIVED_END_BN, &nec_priv->state) ||
 157				     test_bit(DEV_CLEAR_BN, &nec_priv->state) ||
 158				     test_bit(TIMO_NUM, &board->status))) {
 159		retval = -ERESTARTSYS;
 160	}
 161	if (test_bit(TIMO_NUM, &board->status))
 162		retval = -ETIMEDOUT;
 163	if (test_bit(DEV_CLEAR_BN, &nec_priv->state))
 164		retval = -EINTR;
 165	if (test_bit(READ_READY_BN, &nec_priv->state)) {
 166		nec7210_set_handshake_mode(board, nec_priv, HR_HLDA);
 167		buffer[(*bytes_read)++] = nec7210_read_data_in(board, nec_priv, end);
 168	}
 169
 170	return retval;
 171}
 172
 173static int cb7210_accel_read(struct gpib_board *board, u8 *buffer,
 174			     size_t length, int *end, size_t *bytes_read)
 175{
 176	ssize_t retval;
 177	struct cb7210_priv *cb_priv = board->private_data;
 178	struct nec7210_priv *nec_priv = &cb_priv->nec7210_priv;
 179	size_t num_bytes;
 180
 181	*bytes_read = 0;
 182	// deal with limitations of fifo
 183	if (length < cb7210_fifo_size + 3 || (nec_priv->auxa_bits & HR_REOS))
 184		return cb7210_read(board, buffer, length, end, bytes_read);
 185	*end = 0;
 186
 187	nec7210_release_rfd_holdoff(board, nec_priv);
 188
 189	if (wait_event_interruptible(board->wait,
 190				     test_bit(READ_READY_BN, &nec_priv->state) ||
 191				     test_bit(DEV_CLEAR_BN, &nec_priv->state) ||
 192				     test_bit(TIMO_NUM, &board->status))) {
 193		return -ERESTARTSYS;
 194	}
 195	if (test_bit(TIMO_NUM, &board->status))
 196		return -ETIMEDOUT;
 197	if (test_bit(DEV_CLEAR_BN, &nec_priv->state))
 198		return -EINTR;
 199
 200	nec7210_set_handshake_mode(board, nec_priv, HR_HLDE);
 201	buffer[(*bytes_read)++] = nec7210_read_data_in(board, nec_priv, end);
 202	if (*end)
 203		return 0;
 204
 205	nec7210_release_rfd_holdoff(board, nec_priv);
 206
 207	retval = fifo_read(board, cb_priv, &buffer[*bytes_read], length - *bytes_read - 1,
 208			   end, &num_bytes);
 209	*bytes_read += num_bytes;
 210	if (retval < 0)
 211		return retval;
 212	if (*end)
 213		return 0;
 214
 215	retval = cb7210_read(board, &buffer[*bytes_read], 1, end, &num_bytes);
 216	*bytes_read += num_bytes;
 217	if (retval < 0)
 218		return retval;
 219
 220	return 0;
 221}
 222
 223static int output_fifo_empty(const struct cb7210_priv *cb_priv)
 224{
 225	if ((cb7210_read_byte(cb_priv, HS_STATUS) & (HS_TX_MSB_NOT_EMPTY | HS_TX_LSB_NOT_EMPTY))
 226	    == 0)
 227		return 1;
 228	else
 229		return 0;
 230}
 231
 232static inline void output_fifo_enable(struct gpib_board *board, int enable)
 233{
 234	struct cb7210_priv *cb_priv = board->private_data;
 235	struct nec7210_priv *nec_priv = &cb_priv->nec7210_priv;
 236	unsigned long flags;
 237
 238	spin_lock_irqsave(&board->spinlock, flags);
 239
 240	if (enable) {
 241		nec7210_set_reg_bits(nec_priv, IMR1, HR_DOIE, 0);
 242		nec7210_set_reg_bits(nec_priv, IMR2, HR_DMAO, HR_DMAO);
 243
 244		cb7210_write_byte(cb_priv, HS_RX_ENABLE | HS_TX_ENABLE | HS_CLR_SRQ_INT |
 245				  HS_CLR_EOI_EMPTY_INT | HS_CLR_HF_INT | cb_priv->hs_mode_bits,
 246				  HS_MODE);
 247
 248		cb_priv->hs_mode_bits &= ~HS_ENABLE_MASK;
 249		cb_priv->hs_mode_bits |= HS_TX_ENABLE;
 250		cb7210_write_byte(cb_priv, cb_priv->hs_mode_bits, HS_MODE);
 251
 252		cb7210_write_byte(cb_priv, irq_bits(cb_priv->irq), HS_INT_LEVEL);
 253
 254		clear_bit(WRITE_READY_BN, &nec_priv->state);
 255
 256	} else {
 257		cb_priv->hs_mode_bits &= ~HS_ENABLE_MASK;
 258		cb7210_write_byte(cb_priv, cb_priv->hs_mode_bits, HS_MODE);
 259
 260		nec7210_set_reg_bits(nec_priv, IMR2, HR_DMAO, 0);
 261		nec7210_set_reg_bits(nec_priv, IMR1, HR_DOIE, HR_DOIE);
 262	}
 263
 264	spin_unlock_irqrestore(&board->spinlock, flags);
 265}
 266
 267static int fifo_write(struct gpib_board *board, u8 *buffer, size_t length,
 268		      size_t *bytes_written)
 269{
 270	size_t count = 0;
 271	ssize_t retval = 0;
 272	struct cb7210_priv *cb_priv = board->private_data;
 273	struct nec7210_priv *nec_priv = &cb_priv->nec7210_priv;
 274	unsigned int num_bytes, i;
 275	unsigned long flags;
 276
 277	*bytes_written = 0;
 278	if (cb_priv->fifo_iobase == 0) {
 279		dev_err(board->gpib_dev, "fifo iobase is zero!\n");
 280		return -EINVAL;
 281	}
 282	if (length == 0)
 283		return 0;
 284
 285	clear_bit(DEV_CLEAR_BN, &nec_priv->state);
 286	clear_bit(BUS_ERROR_BN, &nec_priv->state);
 287
 288	output_fifo_enable(board, 1);
 289
 290	while (count < length) {
 291		// wait until byte is ready to be sent
 292		if (wait_event_interruptible(board->wait,
 293					     cb_priv->out_fifo_half_empty ||
 294					     output_fifo_empty(cb_priv) ||
 295					     test_bit(DEV_CLEAR_BN, &nec_priv->state) ||
 296					     test_bit(BUS_ERROR_BN, &nec_priv->state) ||
 297					     test_bit(TIMO_NUM, &board->status))) {
 298			retval = -ERESTARTSYS;
 299			break;
 300		}
 301		if (test_bit(TIMO_NUM, &board->status) ||
 302		    test_bit(DEV_CLEAR_BN, &nec_priv->state) ||
 303		    test_bit(BUS_ERROR_BN, &nec_priv->state))
 304			break;
 305
 306		if (output_fifo_empty(cb_priv))
 307			num_bytes = cb7210_fifo_size - cb7210_fifo_width;
 308		else
 309			num_bytes = cb7210_fifo_size / 2;
 310		if (num_bytes + count > length)
 311			num_bytes = length - count;
 312		if (num_bytes % cb7210_fifo_width) {
 313			dev_err(board->gpib_dev, " bug! fifo write with odd number of bytes\n");
 314			retval = -EINVAL;
 315			break;
 316		}
 317
 318		spin_lock_irqsave(&board->spinlock, flags);
 319		for (i = 0; i < num_bytes / cb7210_fifo_width; i++) {
 320			u16 word;
 321
 322			word = buffer[count++] & 0xff;
 323			word |= (buffer[count++] << 8) & 0xff00;
 324			outw(word, cb_priv->fifo_iobase + CDOR);
 325		}
 326		cb_priv->out_fifo_half_empty = 0;
 327		cb7210_write_byte(cb_priv, cb_priv->hs_mode_bits |
 328				  HS_CLR_EOI_EMPTY_INT | HS_CLR_HF_INT, HS_MODE);
 329		cb7210_write_byte(cb_priv, cb_priv->hs_mode_bits, HS_MODE);
 330		spin_unlock_irqrestore(&board->spinlock, flags);
 331	}
 332	// wait last byte has been sent
 333	if (wait_event_interruptible(board->wait,
 334				     output_fifo_empty(cb_priv) ||
 335				     test_bit(DEV_CLEAR_BN, &nec_priv->state) ||
 336				     test_bit(BUS_ERROR_BN, &nec_priv->state) ||
 337				     test_bit(TIMO_NUM, &board->status))) {
 338		retval = -ERESTARTSYS;
 339	}
 340	if (test_bit(TIMO_NUM, &board->status))
 341		retval = -ETIMEDOUT;
 342	if (test_bit(BUS_ERROR_BN, &nec_priv->state))
 343		retval = -EIO;
 344	if (test_bit(DEV_CLEAR_BN, &nec_priv->state))
 345		retval = -EINTR;
 346
 347	output_fifo_enable(board, 0);
 348
 349	*bytes_written = count;
 350	return retval;
 351}
 352
 353static int cb7210_accel_write(struct gpib_board *board, u8 *buffer,
 354			      size_t length, int send_eoi, size_t *bytes_written)
 355{
 356	struct cb7210_priv *cb_priv = board->private_data;
 357	struct nec7210_priv *nec_priv = &cb_priv->nec7210_priv;
 358	unsigned long fast_chunk_size, leftover;
 359	int retval;
 360	size_t num_bytes;
 361
 362	*bytes_written = 0;
 363	if (length > cb7210_fifo_width)
 364		fast_chunk_size = length - 1;
 365	else
 366		fast_chunk_size = 0;
 367	fast_chunk_size -= fast_chunk_size % cb7210_fifo_width;
 368	leftover = length - fast_chunk_size;
 369
 370	retval = fifo_write(board, buffer, fast_chunk_size, &num_bytes);
 371	*bytes_written += num_bytes;
 372	if (retval < 0)
 373		return retval;
 374
 375	retval = nec7210_write(board, nec_priv, buffer + fast_chunk_size, leftover,
 376			       send_eoi, &num_bytes);
 377	*bytes_written += num_bytes;
 378	return retval;
 379}
 380
 381static int cb7210_line_status(const struct gpib_board *board)
 382{
 383	int status = VALID_ALL;
 384	int bsr_bits;
 385	struct cb7210_priv *cb_priv;
 386
 387	cb_priv = board->private_data;
 388
 389	bsr_bits = cb7210_paged_read_byte(cb_priv, BUS_STATUS, BUS_STATUS_PAGE);
 390
 391	if ((bsr_bits & BSR_REN_BIT) == 0)
 392		status |= BUS_REN;
 393	if ((bsr_bits & BSR_IFC_BIT) == 0)
 394		status |= BUS_IFC;
 395	if ((bsr_bits & BSR_SRQ_BIT) == 0)
 396		status |= BUS_SRQ;
 397	if ((bsr_bits & BSR_EOI_BIT) == 0)
 398		status |= BUS_EOI;
 399	if ((bsr_bits & BSR_NRFD_BIT) == 0)
 400		status |= BUS_NRFD;
 401	if ((bsr_bits & BSR_NDAC_BIT) == 0)
 402		status |= BUS_NDAC;
 403	if ((bsr_bits & BSR_DAV_BIT) == 0)
 404		status |= BUS_DAV;
 405	if ((bsr_bits & BSR_ATN_BIT) == 0)
 406		status |= BUS_ATN;
 407
 408	return status;
 409}
 410
 411static int cb7210_t1_delay(struct gpib_board *board, unsigned int nano_sec)
 412{
 413	struct cb7210_priv *cb_priv = board->private_data;
 414	struct nec7210_priv *nec_priv = &cb_priv->nec7210_priv;
 415	unsigned int retval;
 416
 417	retval = nec7210_t1_delay(board, nec_priv, nano_sec);
 418
 419	if (nano_sec <= 350) {
 420		write_byte(nec_priv, AUX_HI_SPEED, AUXMR);
 421		retval = 350;
 422	} else {
 423		write_byte(nec_priv, AUX_LO_SPEED, AUXMR);
 424	}
 425	return retval;
 426}
 427
 428static irqreturn_t cb7210_locked_internal_interrupt(struct gpib_board *board);
 429
 430/*
 431 * GPIB interrupt service routines
 432 */
 433
 434static irqreturn_t cb_pci_interrupt(int irq, void *arg)
 435{
 436	int bits;
 437	struct gpib_board *board = arg;
 438	struct cb7210_priv *priv = board->private_data;
 439
 440	// first task check if this is really our interrupt in a shared irq environment
 441	switch (priv->pci_chip)	{
 442	case PCI_CHIP_AMCC_S5933:
 443		if ((inl(priv->amcc_iobase + INTCSR_REG) &
 444		     (INBOX_INTR_CS_BIT | INTR_ASSERTED_BIT)) == 0)
 445			return IRQ_NONE;
 446
 447		// read incoming mailbox to clear mailbox full flag
 448		inl(priv->amcc_iobase + INCOMING_MAILBOX_REG(3));
 449		// clear amccs5933 interrupt
 450		bits = INBOX_FULL_INTR_BIT | INBOX_BYTE_BITS(3) |
 451			INBOX_SELECT_BITS(3) |	INBOX_INTR_CS_BIT;
 452		outl(bits, priv->amcc_iobase + INTCSR_REG);
 453		break;
 454	case PCI_CHIP_QUANCOM:
 455		if ((inb(nec7210_iobase(priv) + QUANCOM_IRQ_CONTROL_STATUS_REG) &
 456		     QUANCOM_IRQ_ASSERTED_BIT))
 457			outb(QUANCOM_IRQ_ENABLE_BIT, nec7210_iobase(priv) +
 458			     QUANCOM_IRQ_CONTROL_STATUS_REG);
 459		break;
 460	default:
 461		break;
 462	}
 463	return cb7210_locked_internal_interrupt(arg);
 464}
 465
 466static irqreturn_t cb7210_internal_interrupt(struct gpib_board *board)
 467{
 468	int hs_status, status1, status2;
 469	struct cb7210_priv *priv = board->private_data;
 470	struct nec7210_priv *nec_priv = &priv->nec7210_priv;
 471	int clear_bits;
 472
 473	if ((priv->hs_mode_bits & HS_ENABLE_MASK)) {
 474		status1 = 0;
 475		hs_status = cb7210_read_byte(priv, HS_STATUS);
 476	} else {
 477		hs_status = 0;
 478		status1 = read_byte(nec_priv, ISR1);
 479	}
 480	status2 = read_byte(nec_priv, ISR2);
 481	nec7210_interrupt_have_status(board, nec_priv, status1, status2);
 482
 483	dev_dbg(board->gpib_dev, "status 0x%x, mode 0x%x\n", hs_status, priv->hs_mode_bits);
 484
 485	clear_bits = 0;
 486
 487	if (hs_status & HS_HALF_FULL) {
 488		if (priv->hs_mode_bits & HS_TX_ENABLE)
 489			priv->out_fifo_half_empty = 1;
 490		else if (priv->hs_mode_bits & HS_RX_ENABLE)
 491			priv->in_fifo_half_full = 1;
 492		clear_bits |= HS_CLR_HF_INT;
 493	}
 494
 495	if (hs_status & HS_SRQ_INT) {
 496		set_bit(SRQI_NUM, &board->status);
 497		clear_bits |= HS_CLR_SRQ_INT;
 498	}
 499
 500	if ((hs_status & HS_EOI_INT)) {
 501		clear_bits |= HS_CLR_EOI_EMPTY_INT;
 502		set_bit(RECEIVED_END_BN, &nec_priv->state);
 503		if ((nec_priv->auxa_bits & HR_HANDSHAKE_MASK) == HR_HLDE)
 504			set_bit(RFD_HOLDOFF_BN, &nec_priv->state);
 505	}
 506
 507	if ((priv->hs_mode_bits & HS_TX_ENABLE) &&
 508	    (hs_status & (HS_TX_MSB_NOT_EMPTY | HS_TX_LSB_NOT_EMPTY)) == 0)
 509		clear_bits |= HS_CLR_EOI_EMPTY_INT;
 510
 511	if (clear_bits) {
 512		cb7210_write_byte(priv, priv->hs_mode_bits | clear_bits, HS_MODE);
 513		cb7210_write_byte(priv, priv->hs_mode_bits, HS_MODE);
 514		wake_up_interruptible(&board->wait);
 515	}
 516
 517	return IRQ_HANDLED;
 518}
 519
 520static irqreturn_t cb7210_locked_internal_interrupt(struct gpib_board *board)
 521{
 522	unsigned long flags;
 523	irqreturn_t retval;
 524
 525	spin_lock_irqsave(&board->spinlock, flags);
 526	retval = cb7210_internal_interrupt(board);
 527	spin_unlock_irqrestore(&board->spinlock, flags);
 528	return retval;
 529}
 530
 531static irqreturn_t cb7210_interrupt(int irq, void *arg)
 532{
 533	return cb7210_internal_interrupt(arg);
 534}
 535
 536static int cb_pci_attach(struct gpib_board *board, const struct gpib_board_config *config);
 537static int cb_isa_attach(struct gpib_board *board, const struct gpib_board_config *config);
 538
 539static void cb_pci_detach(struct gpib_board *board);
 540static void cb_isa_detach(struct gpib_board *board);
 541
 542// wrappers for interface functions
 543static int cb7210_read(struct gpib_board *board, u8 *buffer, size_t length,
 544		       int *end, size_t *bytes_read)
 545{
 546	struct cb7210_priv *priv = board->private_data;
 547
 548	return nec7210_read(board, &priv->nec7210_priv, buffer, length, end, bytes_read);
 549}
 550
 551static int cb7210_write(struct gpib_board *board, u8 *buffer, size_t length,
 552			int send_eoi, size_t *bytes_written)
 553{
 554	struct cb7210_priv *priv = board->private_data;
 555
 556	return nec7210_write(board, &priv->nec7210_priv, buffer, length, send_eoi, bytes_written);
 557}
 558
 559static int cb7210_command(struct gpib_board *board, u8 *buffer, size_t length,
 560			  size_t *bytes_written)
 561{
 562	struct cb7210_priv *priv = board->private_data;
 563
 564	return nec7210_command(board, &priv->nec7210_priv, buffer, length, bytes_written);
 565}
 566
 567static int cb7210_take_control(struct gpib_board *board, int synchronous)
 568{
 569	struct cb7210_priv *priv = board->private_data;
 570
 571	return nec7210_take_control(board, &priv->nec7210_priv, synchronous);
 572}
 573
 574static int cb7210_go_to_standby(struct gpib_board *board)
 575{
 576	struct cb7210_priv *priv = board->private_data;
 577
 578	return nec7210_go_to_standby(board, &priv->nec7210_priv);
 579}
 580
 581static int cb7210_request_system_control(struct gpib_board *board, int request_control)
 582{
 583	struct cb7210_priv *priv = board->private_data;
 584	struct nec7210_priv *nec_priv = &priv->nec7210_priv;
 585
 586	if (request_control)
 587		priv->hs_mode_bits |= HS_SYS_CONTROL;
 588	else
 589		priv->hs_mode_bits &= ~HS_SYS_CONTROL;
 590
 591	cb7210_write_byte(priv, priv->hs_mode_bits, HS_MODE);
 592	return nec7210_request_system_control(board, nec_priv, request_control);
 593}
 594
 595static void cb7210_interface_clear(struct gpib_board *board, int assert)
 596{
 597	struct cb7210_priv *priv = board->private_data;
 598
 599	nec7210_interface_clear(board, &priv->nec7210_priv, assert);
 600}
 601
 602static void cb7210_remote_enable(struct gpib_board *board, int enable)
 603{
 604	struct cb7210_priv *priv = board->private_data;
 605
 606	nec7210_remote_enable(board, &priv->nec7210_priv, enable);
 607}
 608
 609static int cb7210_enable_eos(struct gpib_board *board, u8 eos_byte, int compare_8_bits)
 610{
 611	struct cb7210_priv *priv = board->private_data;
 612
 613	return nec7210_enable_eos(board, &priv->nec7210_priv, eos_byte, compare_8_bits);
 614}
 615
 616static void cb7210_disable_eos(struct gpib_board *board)
 617{
 618	struct cb7210_priv *priv = board->private_data;
 619
 620	nec7210_disable_eos(board, &priv->nec7210_priv);
 621}
 622
 623static unsigned int cb7210_update_status(struct gpib_board *board, unsigned int clear_mask)
 624{
 625	struct cb7210_priv *priv = board->private_data;
 626
 627	return nec7210_update_status(board, &priv->nec7210_priv, clear_mask);
 628}
 629
 630static int cb7210_primary_address(struct gpib_board *board, unsigned int address)
 631{
 632	struct cb7210_priv *priv = board->private_data;
 633
 634	return nec7210_primary_address(board, &priv->nec7210_priv, address);
 635}
 636
 637static int cb7210_secondary_address(struct gpib_board *board, unsigned int address, int enable)
 638{
 639	struct cb7210_priv *priv = board->private_data;
 640
 641	return nec7210_secondary_address(board, &priv->nec7210_priv, address, enable);
 642}
 643
 644static int cb7210_parallel_poll(struct gpib_board *board, u8 *result)
 645{
 646	struct cb7210_priv *priv = board->private_data;
 647
 648	return nec7210_parallel_poll(board, &priv->nec7210_priv, result);
 649}
 650
 651static void cb7210_parallel_poll_configure(struct gpib_board *board, u8 configuration)
 652{
 653	struct cb7210_priv *priv = board->private_data;
 654
 655	nec7210_parallel_poll_configure(board, &priv->nec7210_priv, configuration);
 656}
 657
 658static void cb7210_parallel_poll_response(struct gpib_board *board, int ist)
 659{
 660	struct cb7210_priv *priv = board->private_data;
 661
 662	nec7210_parallel_poll_response(board, &priv->nec7210_priv, ist);
 663}
 664
 665static void cb7210_serial_poll_response(struct gpib_board *board, u8 status)
 666{
 667	struct cb7210_priv *priv = board->private_data;
 668
 669	nec7210_serial_poll_response(board, &priv->nec7210_priv, status);
 670}
 671
 672static u8 cb7210_serial_poll_status(struct gpib_board *board)
 673{
 674	struct cb7210_priv *priv = board->private_data;
 675
 676	return nec7210_serial_poll_status(board, &priv->nec7210_priv);
 677}
 678
 679static void cb7210_return_to_local(struct gpib_board *board)
 680{
 681	struct cb7210_priv *priv = board->private_data;
 682	struct nec7210_priv *nec_priv = &priv->nec7210_priv;
 683
 684	write_byte(nec_priv, AUX_RTL2, AUXMR);
 685	udelay(1);
 686	write_byte(nec_priv, AUX_RTL, AUXMR);
 687}
 688
 689static struct gpib_interface cb_pci_unaccel_interface = {
 690	.name = "cbi_pci_unaccel",
 691	.attach = cb_pci_attach,
 692	.detach = cb_pci_detach,
 693	.read = cb7210_read,
 694	.write = cb7210_write,
 695	.command = cb7210_command,
 696	.take_control = cb7210_take_control,
 697	.go_to_standby = cb7210_go_to_standby,
 698	.request_system_control = cb7210_request_system_control,
 699	.interface_clear = cb7210_interface_clear,
 700	.remote_enable = cb7210_remote_enable,
 701	.enable_eos = cb7210_enable_eos,
 702	.disable_eos = cb7210_disable_eos,
 703	.parallel_poll = cb7210_parallel_poll,
 704	.parallel_poll_configure = cb7210_parallel_poll_configure,
 705	.parallel_poll_response = cb7210_parallel_poll_response,
 706	.local_parallel_poll_mode = NULL, // XXX
 707	.line_status = cb7210_line_status,
 708	.update_status = cb7210_update_status,
 709	.primary_address = cb7210_primary_address,
 710	.secondary_address = cb7210_secondary_address,
 711	.serial_poll_response = cb7210_serial_poll_response,
 712	.serial_poll_status = cb7210_serial_poll_status,
 713	.t1_delay = cb7210_t1_delay,
 714	.return_to_local = cb7210_return_to_local,
 715};
 716
 717static struct gpib_interface cb_pci_accel_interface = {
 718	.name = "cbi_pci_accel",
 719	.attach = cb_pci_attach,
 720	.detach = cb_pci_detach,
 721	.read = cb7210_accel_read,
 722	.write = cb7210_accel_write,
 723	.command = cb7210_command,
 724	.take_control = cb7210_take_control,
 725	.go_to_standby = cb7210_go_to_standby,
 726	.request_system_control = cb7210_request_system_control,
 727	.interface_clear = cb7210_interface_clear,
 728	.remote_enable = cb7210_remote_enable,
 729	.enable_eos = cb7210_enable_eos,
 730	.disable_eos = cb7210_disable_eos,
 731	.parallel_poll = cb7210_parallel_poll,
 732	.parallel_poll_configure = cb7210_parallel_poll_configure,
 733	.parallel_poll_response = cb7210_parallel_poll_response,
 734	.local_parallel_poll_mode = NULL, // XXX
 735	.line_status = cb7210_line_status,
 736	.update_status = cb7210_update_status,
 737	.primary_address = cb7210_primary_address,
 738	.secondary_address = cb7210_secondary_address,
 739	.serial_poll_response = cb7210_serial_poll_response,
 740	.serial_poll_status = cb7210_serial_poll_status,
 741	.t1_delay = cb7210_t1_delay,
 742	.return_to_local = cb7210_return_to_local,
 743};
 744
 745static struct gpib_interface cb_pci_interface = {
 746	.name = "cbi_pci",
 747	.attach = cb_pci_attach,
 748	.detach = cb_pci_detach,
 749	.read = cb7210_accel_read,
 750	.write = cb7210_accel_write,
 751	.command = cb7210_command,
 752	.take_control = cb7210_take_control,
 753	.go_to_standby = cb7210_go_to_standby,
 754	.request_system_control = cb7210_request_system_control,
 755	.interface_clear = cb7210_interface_clear,
 756	.remote_enable = cb7210_remote_enable,
 757	.enable_eos = cb7210_enable_eos,
 758	.disable_eos = cb7210_disable_eos,
 759	.parallel_poll = cb7210_parallel_poll,
 760	.parallel_poll_configure = cb7210_parallel_poll_configure,
 761	.parallel_poll_response = cb7210_parallel_poll_response,
 762	.line_status = cb7210_line_status,
 763	.update_status = cb7210_update_status,
 764	.primary_address = cb7210_primary_address,
 765	.secondary_address = cb7210_secondary_address,
 766	.serial_poll_response = cb7210_serial_poll_response,
 767	.serial_poll_status = cb7210_serial_poll_status,
 768	.t1_delay = cb7210_t1_delay,
 769	.return_to_local = cb7210_return_to_local,
 770};
 771
 772static struct gpib_interface cb_isa_unaccel_interface = {
 773	.name = "cbi_isa_unaccel",
 774	.attach = cb_isa_attach,
 775	.detach = cb_isa_detach,
 776	.read = cb7210_read,
 777	.write = cb7210_write,
 778	.command = cb7210_command,
 779	.take_control = cb7210_take_control,
 780	.go_to_standby = cb7210_go_to_standby,
 781	.request_system_control = cb7210_request_system_control,
 782	.interface_clear = cb7210_interface_clear,
 783	.remote_enable = cb7210_remote_enable,
 784	.enable_eos = cb7210_enable_eos,
 785	.disable_eos = cb7210_disable_eos,
 786	.parallel_poll = cb7210_parallel_poll,
 787	.parallel_poll_configure = cb7210_parallel_poll_configure,
 788	.parallel_poll_response = cb7210_parallel_poll_response,
 789	.local_parallel_poll_mode = NULL, // XXX
 790	.line_status = cb7210_line_status,
 791	.update_status = cb7210_update_status,
 792	.primary_address = cb7210_primary_address,
 793	.secondary_address = cb7210_secondary_address,
 794	.serial_poll_response = cb7210_serial_poll_response,
 795	.serial_poll_status = cb7210_serial_poll_status,
 796	.t1_delay = cb7210_t1_delay,
 797	.return_to_local = cb7210_return_to_local,
 798};
 799
 800static struct gpib_interface cb_isa_interface = {
 801	.name = "cbi_isa",
 802	.attach = cb_isa_attach,
 803	.detach = cb_isa_detach,
 804	.read = cb7210_accel_read,
 805	.write = cb7210_accel_write,
 806	.command = cb7210_command,
 807	.take_control = cb7210_take_control,
 808	.go_to_standby = cb7210_go_to_standby,
 809	.request_system_control = cb7210_request_system_control,
 810	.interface_clear = cb7210_interface_clear,
 811	.remote_enable = cb7210_remote_enable,
 812	.enable_eos = cb7210_enable_eos,
 813	.disable_eos = cb7210_disable_eos,
 814	.parallel_poll = cb7210_parallel_poll,
 815	.parallel_poll_configure = cb7210_parallel_poll_configure,
 816	.parallel_poll_response = cb7210_parallel_poll_response,
 817	.line_status = cb7210_line_status,
 818	.update_status = cb7210_update_status,
 819	.primary_address = cb7210_primary_address,
 820	.secondary_address = cb7210_secondary_address,
 821	.serial_poll_response = cb7210_serial_poll_response,
 822	.serial_poll_status = cb7210_serial_poll_status,
 823	.t1_delay = cb7210_t1_delay,
 824	.return_to_local = cb7210_return_to_local,
 825};
 826
 827static struct gpib_interface cb_isa_accel_interface = {
 828	.name = "cbi_isa_accel",
 829	.attach = cb_isa_attach,
 830	.detach = cb_isa_detach,
 831	.read = cb7210_accel_read,
 832	.write = cb7210_accel_write,
 833	.command = cb7210_command,
 834	.take_control = cb7210_take_control,
 835	.go_to_standby = cb7210_go_to_standby,
 836	.request_system_control = cb7210_request_system_control,
 837	.interface_clear = cb7210_interface_clear,
 838	.remote_enable = cb7210_remote_enable,
 839	.enable_eos = cb7210_enable_eos,
 840	.disable_eos = cb7210_disable_eos,
 841	.parallel_poll = cb7210_parallel_poll,
 842	.parallel_poll_configure = cb7210_parallel_poll_configure,
 843	.parallel_poll_response = cb7210_parallel_poll_response,
 844	.local_parallel_poll_mode = NULL, // XXX
 845	.line_status = cb7210_line_status,
 846	.update_status = cb7210_update_status,
 847	.primary_address = cb7210_primary_address,
 848	.secondary_address = cb7210_secondary_address,
 849	.serial_poll_response = cb7210_serial_poll_response,
 850	.serial_poll_status = cb7210_serial_poll_status,
 851	.t1_delay = cb7210_t1_delay,
 852	.return_to_local = cb7210_return_to_local,
 853};
 854
 855static int cb7210_allocate_private(struct gpib_board *board)
 856{
 857	struct cb7210_priv *priv;
 858
 859	board->private_data = kmalloc(sizeof(struct cb7210_priv), GFP_KERNEL);
 860	if (!board->private_data)
 861		return -ENOMEM;
 862	priv = board->private_data;
 863	memset(priv, 0, sizeof(struct cb7210_priv));
 864	init_nec7210_private(&priv->nec7210_priv);
 865	return 0;
 866}
 867
 868static void cb7210_generic_detach(struct gpib_board *board)
 869{
 870	kfree(board->private_data);
 871	board->private_data = NULL;
 872}
 873
 874// generic part of attach functions shared by all cb7210 boards
 875static int cb7210_generic_attach(struct gpib_board *board)
 876{
 877	struct cb7210_priv *cb_priv;
 878	struct nec7210_priv *nec_priv;
 879
 880	board->status = 0;
 881
 882	if (cb7210_allocate_private(board))
 883		return -ENOMEM;
 884	cb_priv = board->private_data;
 885	nec_priv = &cb_priv->nec7210_priv;
 886	nec_priv->read_byte = nec7210_locking_ioport_read_byte;
 887	nec_priv->write_byte = nec7210_locking_ioport_write_byte;
 888	nec_priv->offset = cb7210_reg_offset;
 889	nec_priv->type = CB7210;
 890	return 0;
 891}
 892
 893static int cb7210_init(struct cb7210_priv *cb_priv, struct gpib_board *board)
 894{
 895	struct nec7210_priv *nec_priv = &cb_priv->nec7210_priv;
 896
 897	cb7210_write_byte(cb_priv, HS_RESET7210, HS_INT_LEVEL);
 898	cb7210_write_byte(cb_priv, irq_bits(cb_priv->irq), HS_INT_LEVEL);
 899
 900	nec7210_board_reset(nec_priv, board);
 901	cb7210_write_byte(cb_priv, HS_TX_ENABLE | HS_RX_ENABLE | HS_CLR_SRQ_INT |
 902			  HS_CLR_EOI_EMPTY_INT | HS_CLR_HF_INT, HS_MODE);
 903
 904	cb_priv->hs_mode_bits = HS_HF_INT_EN;
 905	cb7210_write_byte(cb_priv, cb_priv->hs_mode_bits, HS_MODE);
 906
 907	write_byte(nec_priv, AUX_LO_SPEED, AUXMR);
 908	/*
 909	 * set clock register for maximum (20 MHz) driving frequency
 910	 * ICR should be set to clock in megahertz (1-15) and to zero
 911	 * for clocks faster than 15 MHz (max 20MHz)
 912	 */
 913	write_byte(nec_priv, ICR | 0, AUXMR);
 914
 915	if (cb_priv->pci_chip == PCI_CHIP_QUANCOM) {
 916		/* change interrupt polarity */
 917		nec_priv->auxb_bits |= HR_INV;
 918		write_byte(nec_priv, nec_priv->auxb_bits, AUXMR);
 919	}
 920	nec7210_board_online(nec_priv, board);
 921
 922	/* poll so we can detect assertion of ATN */
 923	if (gpib_request_pseudo_irq(board, cb_pci_interrupt)) {
 924		pr_err("failed to allocate pseudo_irq\n");
 925		return -1;
 926	}
 927	return 0;
 928}
 929
 930static int cb_pci_attach(struct gpib_board *board, const struct gpib_board_config *config)
 931{
 932	struct cb7210_priv *cb_priv;
 933	struct nec7210_priv *nec_priv;
 934	int isr_flags = 0;
 935	int bits;
 936	int retval;
 937
 938	retval = cb7210_generic_attach(board);
 939	if (retval)
 940		return retval;
 941
 942	cb_priv = board->private_data;
 943	nec_priv = &cb_priv->nec7210_priv;
 944
 945	cb_priv->pci_device = gpib_pci_get_device(config, PCI_VENDOR_ID_CBOARDS,
 946						  PCI_DEVICE_ID_CBOARDS_PCI_GPIB, NULL);
 947	if (cb_priv->pci_device)
 948		cb_priv->pci_chip = PCI_CHIP_AMCC_S5933;
 949	if (!cb_priv->pci_device) {
 950		cb_priv->pci_device = gpib_pci_get_device(config, PCI_VENDOR_ID_CBOARDS,
 951							  PCI_DEVICE_ID_CBOARDS_CPCI_GPIB, NULL);
 952		if (cb_priv->pci_device)
 953			cb_priv->pci_chip = PCI_CHIP_AMCC_S5933;
 954	}
 955	if (!cb_priv->pci_device) {
 956		cb_priv->pci_device = gpib_pci_get_device(config, PCI_VENDOR_ID_QUANCOM,
 957							  PCI_DEVICE_ID_QUANCOM_GPIB, NULL);
 958		if (cb_priv->pci_device) {
 959			cb_priv->pci_chip = PCI_CHIP_QUANCOM;
 960			nec_priv->offset = 4;
 961		}
 962	}
 963	if (!cb_priv->pci_device) {
 964		dev_err(board->gpib_dev, "no supported boards found.\n");
 965		return -ENODEV;
 966	}
 967
 968	if (pci_enable_device(cb_priv->pci_device)) {
 969		dev_err(board->gpib_dev, "error enabling pci device\n");
 970		return -EIO;
 971	}
 972
 973	if (pci_request_regions(cb_priv->pci_device, DRV_NAME))
 974		return -EBUSY;
 975	switch (cb_priv->pci_chip) {
 976	case PCI_CHIP_AMCC_S5933:
 977		cb_priv->amcc_iobase = pci_resource_start(cb_priv->pci_device, 0);
 978		nec_priv->iobase = pci_resource_start(cb_priv->pci_device, 1);
 979		cb_priv->fifo_iobase = pci_resource_start(cb_priv->pci_device, 2);
 980		break;
 981	case PCI_CHIP_QUANCOM:
 982		nec_priv->iobase = pci_resource_start(cb_priv->pci_device, 0);
 983		cb_priv->fifo_iobase = nec_priv->iobase;
 984		break;
 985	default:
 986		dev_err(board->gpib_dev, "bug! unhandled pci_chip=%i\n", cb_priv->pci_chip);
 987		return -EIO;
 988	}
 989	isr_flags |= IRQF_SHARED;
 990	if (request_irq(cb_priv->pci_device->irq, cb_pci_interrupt, isr_flags, DRV_NAME, board)) {
 991		dev_err(board->gpib_dev, "can't request IRQ %d\n",
 992			cb_priv->pci_device->irq);
 993		return -EBUSY;
 994	}
 995	cb_priv->irq = cb_priv->pci_device->irq;
 996
 997	switch (cb_priv->pci_chip) {
 998	case PCI_CHIP_AMCC_S5933:
 999		// make sure mailbox flags are clear
1000		inl(cb_priv->amcc_iobase + INCOMING_MAILBOX_REG(3));
1001		// enable interrupts on amccs5933 chip
1002		bits = INBOX_FULL_INTR_BIT | INBOX_BYTE_BITS(3) | INBOX_SELECT_BITS(3) |
1003			INBOX_INTR_CS_BIT;
1004		outl(bits, cb_priv->amcc_iobase + INTCSR_REG);
1005		break;
1006	default:
1007		break;
1008	}
1009	return cb7210_init(cb_priv, board);
1010}
1011
1012static void cb_pci_detach(struct gpib_board *board)
1013{
1014	struct cb7210_priv *cb_priv = board->private_data;
1015	struct nec7210_priv *nec_priv;
1016
1017	if (cb_priv) {
1018		gpib_free_pseudo_irq(board);
1019		nec_priv = &cb_priv->nec7210_priv;
1020		if (cb_priv->irq) {
1021			// disable amcc interrupts
1022			outl(0, cb_priv->amcc_iobase + INTCSR_REG);
1023			free_irq(cb_priv->irq, board);
1024		}
1025		if (nec_priv->iobase) {
1026			nec7210_board_reset(nec_priv, board);
1027			pci_release_regions(cb_priv->pci_device);
1028		}
1029		if (cb_priv->pci_device)
1030			pci_dev_put(cb_priv->pci_device);
1031	}
1032	cb7210_generic_detach(board);
1033}
1034
1035static int cb_isa_attach(struct gpib_board *board, const struct gpib_board_config *config)
1036{
1037	int isr_flags = 0;
1038	struct cb7210_priv *cb_priv;
1039	struct nec7210_priv *nec_priv;
1040	unsigned int bits;
1041	int retval;
1042
1043	retval = cb7210_generic_attach(board);
1044	if (retval)
1045		return retval;
1046	cb_priv = board->private_data;
1047	nec_priv = &cb_priv->nec7210_priv;
1048	if (!request_region(config->ibbase, cb7210_iosize, DRV_NAME)) {
1049		dev_err(board->gpib_dev, "ioports starting at 0x%x are already in use\n",
1050			config->ibbase);
1051		return -EBUSY;
1052	}
1053	nec_priv->iobase = config->ibbase;
1054	cb_priv->fifo_iobase = nec7210_iobase(cb_priv);
1055
1056	bits = irq_bits(config->ibirq);
1057	if (bits == 0)
1058		dev_err(board->gpib_dev, "board incapable of using irq %i, try 2-5, 7, 10, or 11\n",
1059			config->ibirq);
1060
1061	// install interrupt handler
1062	if (request_irq(config->ibirq, cb7210_interrupt, isr_flags, DRV_NAME, board)) {
1063		dev_err(board->gpib_dev, "failed to obtain IRQ %d\n", config->ibirq);
1064		return -EBUSY;
1065	}
1066	cb_priv->irq = config->ibirq;
1067
1068	return cb7210_init(cb_priv, board);
1069}
1070
1071static void cb_isa_detach(struct gpib_board *board)
1072{
1073	struct cb7210_priv *cb_priv = board->private_data;
1074	struct nec7210_priv *nec_priv;
1075
1076	if (cb_priv) {
1077		gpib_free_pseudo_irq(board);
1078		nec_priv = &cb_priv->nec7210_priv;
1079		if (cb_priv->irq)
1080			free_irq(cb_priv->irq, board);
1081		if (nec_priv->iobase) {
1082			nec7210_board_reset(nec_priv, board);
1083			release_region(nec7210_iobase(cb_priv), cb7210_iosize);
1084		}
1085	}
1086	cb7210_generic_detach(board);
1087}
1088
1089static int cb7210_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
1090{
1091	return 0;
1092}
1093
1094static const struct pci_device_id cb7210_pci_table[] = {
1095	{PCI_VENDOR_ID_CBOARDS, PCI_DEVICE_ID_CBOARDS_PCI_GPIB, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
1096	{PCI_VENDOR_ID_CBOARDS, PCI_DEVICE_ID_CBOARDS_CPCI_GPIB, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
1097	{PCI_VENDOR_ID_QUANCOM, PCI_DEVICE_ID_QUANCOM_GPIB, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
1098	{ 0 }
1099};
1100MODULE_DEVICE_TABLE(pci, cb7210_pci_table);
1101
1102static struct pci_driver cb7210_pci_driver = {
1103	.name = DRV_NAME,
1104	.id_table = cb7210_pci_table,
1105	.probe = &cb7210_pci_probe
1106};
1107
1108/***************************************************************************
1109 *  Support for computer boards pcmcia-gpib card
1110 *
1111 *  Based on gpib PCMCIA client driver written by Claus Schroeter
1112 *  (clausi@chemie.fu-berlin.de), which was adapted from the
1113 *  pcmcia skeleton example (presumably David Hinds)
1114 ***************************************************************************/
1115
1116#ifdef CONFIG_GPIB_PCMCIA
1117
1118#include <linux/kernel.h>
1119#include <linux/ptrace.h>
1120#include <linux/timer.h>
1121#include <linux/io.h>
1122
1123#include <pcmcia/cistpl.h>
1124#include <pcmcia/ds.h>
1125
1126/*
1127 * The event() function is this driver's Card Services event handler.
1128 * It will be called by Card Services when an appropriate card status
1129 * event is received.  The config() and release() entry points are
1130 * used to configure or release a socket, in response to card insertion
1131 * and ejection events.	 They are invoked from the gpib event
1132 * handler.
1133 */
1134
1135static int cb_gpib_config(struct pcmcia_device	*link);
1136static void cb_gpib_release(struct pcmcia_device  *link);
1137static int cb_pcmcia_attach(struct gpib_board *board, const struct gpib_board_config *config);
1138static void cb_pcmcia_detach(struct gpib_board *board);
1139
1140/*
1141 *  A linked list of "instances" of the gpib device.  Each actual
1142 *  PCMCIA card corresponds to one device instance, and is described
1143 *  by one dev_link_t structure (defined in ds.h).
1144 *
1145 *  You may not want to use a linked list for this -- for example, the
1146 *  memory card driver uses an array of dev_link_t pointers, where minor
1147 *  device numbers are used to derive the corresponding array index.
1148 */
1149
1150static	struct pcmcia_device  *curr_dev;
1151
1152/*
1153 *  A dev_link_t structure has fields for most things that are needed
1154 *  to keep track of a socket, but there will usually be some device
1155 *  specific information that also needs to be kept track of.  The
1156 *  'priv' pointer in a dev_link_t structure can be used to point to
1157 *  a device-specific private data structure, like this.
1158 *
1159 *  A driver needs to provide a dev_node_t structure for each device
1160 *  on a card.	In some cases, there is only one device per card (for
1161 *  example, ethernet cards, modems).  In other cases, there may be
1162 *  many actual or logical devices (SCSI adapters, memory cards with
1163 *  multiple partitions).  The dev_node_t structures need to be kept
1164 *  in a linked list starting at the 'dev' field of a dev_link_t
1165 *  structure.	We allocate them in the card's private data structure,
1166 * because they generally can't be allocated dynamically.
1167 */
1168
1169struct local_info {
1170	struct pcmcia_device	*p_dev;
1171	struct gpib_board		*dev;
1172};
1173
1174/*
1175 *  gpib_attach() creates an "instance" of the driver, allocating
1176 *  local data structures for one device.  The device is registered
1177 *  with Card Services.
1178 *
1179 *  The dev_link structure is initialized, but we don't actually
1180 *  configure the card at this point -- we wait until we receive a
1181 *  card insertion event.
1182 */
1183
1184static int cb_gpib_probe(struct pcmcia_device *link)
1185{
1186	struct local_info *info;
1187	int ret;
1188
1189	/* Allocate space for private device-specific data */
1190	info = kzalloc(sizeof(*info), GFP_KERNEL);
1191	if (!info)
1192		return -ENOMEM;
1193
1194	info->p_dev = link;
1195	link->priv = info;
1196
1197	/* The io structure describes IO port mapping */
1198	link->resource[0]->end = 16;
1199	link->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
1200	link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
1201	link->resource[1]->end = 16;
1202	link->resource[1]->flags &= ~IO_DATA_PATH_WIDTH;
1203	link->resource[1]->flags |= IO_DATA_PATH_WIDTH_16;
1204	link->io_lines = 10;
1205
1206	/* General socket configuration */
1207	link->config_flags = CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
1208	link->config_index = 1;
1209	link->config_regs = PRESENT_OPTION;
1210
1211	/* Register with Card Services */
1212	curr_dev = link;
1213	ret = cb_gpib_config(link);
1214	if (ret)
1215		goto free_info;
1216
1217	return 0;
1218
1219free_info:
1220	kfree(info);
1221	return ret;
1222}
1223
1224/*
1225 *   This deletes a driver "instance".  The device is de-registered
1226 *   with Card Services.  If it has been released, all local data
1227 *   structures are freed.  Otherwise, the structures will be freed
1228 *   when the device is released.
1229 */
1230
1231static void cb_gpib_remove(struct pcmcia_device *link)
1232{
1233	struct local_info *info = link->priv;
1234	//struct struct gpib_board *dev = info->dev;
1235
1236	if (info->dev)
1237		cb_pcmcia_detach(info->dev);
1238	cb_gpib_release(link);
1239
1240	//free_netdev(dev);
1241	kfree(info);
1242}
1243
1244static int cb_gpib_config_iteration(struct pcmcia_device *link, void *priv_data)
1245{
1246	return pcmcia_request_io(link);
1247}
1248
1249/*
1250 *   gpib_config() is scheduled to run after a CARD_INSERTION event
1251 *   is received, to configure the PCMCIA socket, and to make the
1252 *   ethernet device available to the system.
1253 */
1254
1255static int cb_gpib_config(struct pcmcia_device  *link)
1256{
1257	int retval;
1258
1259	retval = pcmcia_loop_config(link, &cb_gpib_config_iteration, NULL);
1260	if (retval) {
1261		dev_warn(&link->dev, "no configuration found\n");
1262		cb_gpib_release(link);
1263		return -ENODEV;
1264	}
1265
1266	/*
1267	 *  This actually configures the PCMCIA socket -- setting up
1268	 *  the I/O windows and the interrupt mapping.
1269	 */
1270	retval = pcmcia_enable_device(link);
1271	if (retval) {
1272		dev_warn(&link->dev, "pcmcia_enable_device failed\n");
1273		cb_gpib_release(link);
1274		return -ENODEV;
1275	}
1276
1277	return 0;
1278} /* gpib_config */
1279
1280/*
1281 * After a card is removed, gpib_release() will unregister the net
1282 * device, and release the PCMCIA configuration.  If the device is
1283 * still open, this will be postponed until it is closed.
1284 */
1285
1286static void cb_gpib_release(struct pcmcia_device *link)
1287{
1288	pcmcia_disable_device(link);
1289}
1290
1291static int cb_gpib_suspend(struct pcmcia_device *link)
1292{
1293	if (link->open)
1294		dev_warn(&link->dev, "Device still open\n");
1295
1296	return 0;
1297}
1298
1299static int cb_gpib_resume(struct pcmcia_device *link)
1300{
1301	return cb_gpib_config(link);
1302}
1303
1304/*====================================================================*/
1305
1306static struct pcmcia_device_id cb_pcmcia_ids[] = {
1307	PCMCIA_DEVICE_MANF_CARD(0x01c5, 0x0005),
1308	PCMCIA_DEVICE_NULL
1309};
1310MODULE_DEVICE_TABLE(pcmcia, cb_pcmcia_ids);
1311
1312static struct pcmcia_driver cb_gpib_cs_driver = {
1313	.name           = "cb_gpib_cs",
1314	.owner		= THIS_MODULE,
1315	.id_table	= cb_pcmcia_ids,
1316	.probe		= cb_gpib_probe,
1317	.remove		= cb_gpib_remove,
1318	.suspend	= cb_gpib_suspend,
1319	.resume		= cb_gpib_resume,
1320};
1321
1322static void cb_pcmcia_cleanup_module(void)
1323{
1324	pcmcia_unregister_driver(&cb_gpib_cs_driver);
1325}
1326
1327static struct gpib_interface cb_pcmcia_unaccel_interface = {
1328	.name = "cbi_pcmcia_unaccel",
1329	.attach = cb_pcmcia_attach,
1330	.detach = cb_pcmcia_detach,
1331	.read = cb7210_read,
1332	.write = cb7210_write,
1333	.command = cb7210_command,
1334	.take_control = cb7210_take_control,
1335	.go_to_standby = cb7210_go_to_standby,
1336	.request_system_control = cb7210_request_system_control,
1337	.interface_clear = cb7210_interface_clear,
1338	.remote_enable = cb7210_remote_enable,
1339	.enable_eos = cb7210_enable_eos,
1340	.disable_eos = cb7210_disable_eos,
1341	.parallel_poll = cb7210_parallel_poll,
1342	.parallel_poll_configure = cb7210_parallel_poll_configure,
1343	.parallel_poll_response = cb7210_parallel_poll_response,
1344	.local_parallel_poll_mode = NULL, // XXX
1345	.line_status = cb7210_line_status,
1346	.update_status = cb7210_update_status,
1347	.primary_address = cb7210_primary_address,
1348	.secondary_address = cb7210_secondary_address,
1349	.serial_poll_response = cb7210_serial_poll_response,
1350	.serial_poll_status = cb7210_serial_poll_status,
1351	.t1_delay = cb7210_t1_delay,
1352	.return_to_local = cb7210_return_to_local,
1353};
1354
1355static struct gpib_interface cb_pcmcia_interface = {
1356	.name = "cbi_pcmcia",
1357	.attach = cb_pcmcia_attach,
1358	.detach = cb_pcmcia_detach,
1359	.read = cb7210_accel_read,
1360	.write = cb7210_accel_write,
1361	.command = cb7210_command,
1362	.take_control = cb7210_take_control,
1363	.go_to_standby = cb7210_go_to_standby,
1364	.request_system_control = cb7210_request_system_control,
1365	.interface_clear = cb7210_interface_clear,
1366	.remote_enable = cb7210_remote_enable,
1367	.enable_eos = cb7210_enable_eos,
1368	.disable_eos = cb7210_disable_eos,
1369	.parallel_poll = cb7210_parallel_poll,
1370	.parallel_poll_configure = cb7210_parallel_poll_configure,
1371	.parallel_poll_response = cb7210_parallel_poll_response,
1372	.local_parallel_poll_mode = NULL, // XXX
1373	.line_status = cb7210_line_status,
1374	.update_status = cb7210_update_status,
1375	.primary_address = cb7210_primary_address,
1376	.secondary_address = cb7210_secondary_address,
1377	.serial_poll_response = cb7210_serial_poll_response,
1378	.serial_poll_status = cb7210_serial_poll_status,
1379	.t1_delay = cb7210_t1_delay,
1380	.return_to_local = cb7210_return_to_local,
1381};
1382
1383static struct gpib_interface cb_pcmcia_accel_interface = {
1384	.name = "cbi_pcmcia_accel",
1385	.attach = cb_pcmcia_attach,
1386	.detach = cb_pcmcia_detach,
1387	.read = cb7210_accel_read,
1388	.write = cb7210_accel_write,
1389	.command = cb7210_command,
1390	.take_control = cb7210_take_control,
1391	.go_to_standby = cb7210_go_to_standby,
1392	.request_system_control = cb7210_request_system_control,
1393	.interface_clear = cb7210_interface_clear,
1394	.remote_enable = cb7210_remote_enable,
1395	.enable_eos = cb7210_enable_eos,
1396	.disable_eos = cb7210_disable_eos,
1397	.parallel_poll = cb7210_parallel_poll,
1398	.parallel_poll_configure = cb7210_parallel_poll_configure,
1399	.parallel_poll_response = cb7210_parallel_poll_response,
1400	.local_parallel_poll_mode = NULL, // XXX
1401	.line_status = cb7210_line_status,
1402	.update_status = cb7210_update_status,
1403	.primary_address = cb7210_primary_address,
1404	.secondary_address = cb7210_secondary_address,
1405	.serial_poll_response = cb7210_serial_poll_response,
1406	.serial_poll_status = cb7210_serial_poll_status,
1407	.t1_delay = cb7210_t1_delay,
1408	.return_to_local = cb7210_return_to_local,
1409};
1410
1411static int cb_pcmcia_attach(struct gpib_board *board, const struct gpib_board_config *config)
1412{
1413	struct cb7210_priv *cb_priv;
1414	struct nec7210_priv *nec_priv;
1415	int retval;
1416
1417	if (!curr_dev) {
1418		dev_err(board->gpib_dev, "no cb pcmcia cards found\n");
1419		return -ENODEV;
1420	}
1421
1422	retval = cb7210_generic_attach(board);
1423	if (retval)
1424		return retval;
1425
1426	cb_priv = board->private_data;
1427	nec_priv = &cb_priv->nec7210_priv;
1428
1429	if (!request_region(curr_dev->resource[0]->start, resource_size(curr_dev->resource[0]),
1430			    DRV_NAME))	{
1431		dev_err(board->gpib_dev, "ioports starting at 0x%lx are already in use\n",
1432			(unsigned long)curr_dev->resource[0]->start);
1433		return -EBUSY;
1434	}
1435	nec_priv->iobase = curr_dev->resource[0]->start;
1436	cb_priv->fifo_iobase = curr_dev->resource[0]->start;
1437
1438	if (request_irq(curr_dev->irq, cb7210_interrupt, IRQF_SHARED, DRV_NAME, board)) {
1439		dev_err(board->gpib_dev, "failed to request IRQ %d\n", curr_dev->irq);
1440		return -EBUSY;
1441	}
1442	cb_priv->irq = curr_dev->irq;
1443
1444	return cb7210_init(cb_priv, board);
1445}
1446
1447static void cb_pcmcia_detach(struct gpib_board *board)
1448{
1449	struct cb7210_priv *cb_priv = board->private_data;
1450	struct nec7210_priv *nec_priv;
1451
1452	if (cb_priv) {
1453		nec_priv = &cb_priv->nec7210_priv;
1454		gpib_free_pseudo_irq(board);
1455		if (cb_priv->irq)
1456			free_irq(cb_priv->irq, board);
1457		if (nec_priv->iobase) {
1458			nec7210_board_reset(nec_priv, board);
1459			release_region(nec7210_iobase(cb_priv), cb7210_iosize);
1460		}
1461	}
1462	cb7210_generic_detach(board);
1463}
1464
1465#endif /* CONFIG_GPIB_PCMCIA */
1466
1467static int __init cb7210_init_module(void)
1468{
1469	int ret;
1470
1471	ret = pci_register_driver(&cb7210_pci_driver);
1472	if (ret) {
1473		pr_err("pci_register_driver failed: error = %d\n", ret);
1474		return ret;
1475	}
1476
1477	ret = gpib_register_driver(&cb_pci_interface, THIS_MODULE);
1478	if (ret) {
1479		pr_err("gpib_register_driver failed: error = %d\n", ret);
1480		goto err_pci;
1481	}
1482
1483	ret = gpib_register_driver(&cb_isa_interface, THIS_MODULE);
1484	if (ret) {
1485		pr_err("gpib_register_driver failed: error = %d\n", ret);
1486		goto err_isa;
1487	}
1488
1489	ret = gpib_register_driver(&cb_pci_accel_interface, THIS_MODULE);
1490	if (ret) {
1491		pr_err("gpib_register_driver failed: error = %d\n", ret);
1492		goto err_pci_accel;
1493	}
1494
1495	ret = gpib_register_driver(&cb_pci_unaccel_interface, THIS_MODULE);
1496	if (ret) {
1497		pr_err("gpib_register_driver failed: error = %d\n", ret);
1498		goto err_pci_unaccel;
1499	}
1500
1501	ret = gpib_register_driver(&cb_isa_accel_interface, THIS_MODULE);
1502	if (ret) {
1503		pr_err("gpib_register_driver failed: error = %d\n", ret);
1504		goto err_isa_accel;
1505	}
1506
1507	ret = gpib_register_driver(&cb_isa_unaccel_interface, THIS_MODULE);
1508	if (ret) {
1509		pr_err("gpib_register_driver failed: error = %d\n", ret);
1510		goto err_isa_unaccel;
1511	}
1512
1513#ifdef CONFIG_GPIB_PCMCIA
1514	ret = gpib_register_driver(&cb_pcmcia_interface, THIS_MODULE);
1515	if (ret) {
1516		pr_err("gpib_register_driver failed: error = %d\n", ret);
1517		goto err_pcmcia;
1518	}
1519
1520	ret = gpib_register_driver(&cb_pcmcia_accel_interface, THIS_MODULE);
1521	if (ret) {
1522		pr_err("gpib_register_driver failed: error = %d\n", ret);
1523		goto err_pcmcia_accel;
1524	}
1525
1526	ret = gpib_register_driver(&cb_pcmcia_unaccel_interface, THIS_MODULE);
1527	if (ret) {
1528		pr_err("gpib_register_driver failed: error = %d\n", ret);
1529		goto err_pcmcia_unaccel;
1530	}
1531
1532	ret = pcmcia_register_driver(&cb_gpib_cs_driver);
1533	if (ret) {
1534		pr_err("pcmcia_register_driver failed: error = %d\n", ret);
1535		goto err_pcmcia_driver;
1536	}
1537#endif
1538
1539	return 0;
1540
1541#ifdef CONFIG_GPIB_PCMCIA
1542err_pcmcia_driver:
1543	gpib_unregister_driver(&cb_pcmcia_unaccel_interface);
1544err_pcmcia_unaccel:
1545	gpib_unregister_driver(&cb_pcmcia_accel_interface);
1546err_pcmcia_accel:
1547	gpib_unregister_driver(&cb_pcmcia_interface);
1548err_pcmcia:
1549#endif
1550	gpib_unregister_driver(&cb_isa_unaccel_interface);
1551err_isa_unaccel:
1552	gpib_unregister_driver(&cb_isa_accel_interface);
1553err_isa_accel:
1554	gpib_unregister_driver(&cb_pci_unaccel_interface);
1555err_pci_unaccel:
1556	gpib_unregister_driver(&cb_pci_accel_interface);
1557err_pci_accel:
1558	gpib_unregister_driver(&cb_isa_interface);
1559err_isa:
1560	gpib_unregister_driver(&cb_pci_interface);
1561err_pci:
1562	pci_unregister_driver(&cb7210_pci_driver);
1563
1564	return ret;
1565}
1566
1567static void __exit cb7210_exit_module(void)
1568{
1569	gpib_unregister_driver(&cb_pci_interface);
1570	gpib_unregister_driver(&cb_isa_interface);
1571	gpib_unregister_driver(&cb_pci_accel_interface);
1572	gpib_unregister_driver(&cb_pci_unaccel_interface);
1573	gpib_unregister_driver(&cb_isa_accel_interface);
1574	gpib_unregister_driver(&cb_isa_unaccel_interface);
1575#ifdef CONFIG_GPIB_PCMCIA
1576	gpib_unregister_driver(&cb_pcmcia_interface);
1577	gpib_unregister_driver(&cb_pcmcia_accel_interface);
1578	gpib_unregister_driver(&cb_pcmcia_unaccel_interface);
1579	cb_pcmcia_cleanup_module();
1580#endif
1581
1582	pci_unregister_driver(&cb7210_pci_driver);
1583}
1584
1585module_init(cb7210_init_module);
1586module_exit(cb7210_exit_module);