1
// SPDX-License-Identifier: GPL-2.0
2

3
/***************************************************************************
4
 *    copyright		   : (C) 1999 Axel Dziemba ([email protected])
5
 *			    (C) 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 "ines.h"
13

14
#include <linux/pci.h>
15
#include <linux/pci_ids.h>
16
#include <linux/bitops.h>
17
#include <asm/dma.h>
18
#include <linux/io.h>
19
#include <linux/module.h>
20
#include <linux/init.h>
21
#include <linux/sched.h>
22
#include <linux/slab.h>
23
#include "gpib_pci_ids.h"
24

25
MODULE_LICENSE("GPL");
26
MODULE_DESCRIPTION("GPIB driver for Ines iGPIB 72010");
27

28
static irqreturn_t ines_interrupt(struct gpib_board *board);
29

30
static int ines_line_status(const struct gpib_board *board)
31
{
32
	int status = VALID_ALL;
33
	int bcm_bits;
34
	struct ines_priv *ines_priv;
35

36
	ines_priv = board->private_data;
37

38
	bcm_bits = ines_inb(ines_priv, BUS_CONTROL_MONITOR);
39

40
	if (bcm_bits & BCM_REN_BIT)
41
		status |= BUS_REN;
42
	if (bcm_bits & BCM_IFC_BIT)
43
		status |= BUS_IFC;
44
	if (bcm_bits & BCM_SRQ_BIT)
45
		status |= BUS_SRQ;
46
	if (bcm_bits & BCM_EOI_BIT)
47
		status |= BUS_EOI;
48
	if (bcm_bits & BCM_NRFD_BIT)
49
		status |= BUS_NRFD;
50
	if (bcm_bits & BCM_NDAC_BIT)
51
		status |= BUS_NDAC;
52
	if (bcm_bits & BCM_DAV_BIT)
53
		status |= BUS_DAV;
54
	if (bcm_bits & BCM_ATN_BIT)
55
		status |= BUS_ATN;
56

57
	return status;
58
}
59

60
static void ines_set_xfer_counter(struct ines_priv *priv, unsigned int count)
61
{
62
	if (count > 0xffff) {
63
		pr_err("bug! tried to set xfer counter > 0xffff\n");
64
		return;
65
	}
66
	ines_outb(priv, (count >> 8) & 0xff, XFER_COUNT_UPPER);
67
	ines_outb(priv, count & 0xff, XFER_COUNT_LOWER);
68
}
69

70
static int ines_t1_delay(struct gpib_board *board, unsigned int nano_sec)
71
{
72
	struct ines_priv *ines_priv = board->private_data;
73
	struct nec7210_priv *nec_priv = &ines_priv->nec7210_priv;
74
	unsigned int retval;
75

76
	retval = nec7210_t1_delay(board, nec_priv, nano_sec);
77

78
	if (nano_sec <= 250) {
79
		write_byte(nec_priv, INES_AUXD | INES_FOLLOWING_T1_250ns |
80
			   INES_INITIAL_T1_2000ns, AUXMR);
81
		retval = 250;
82
	} else if (nano_sec <= 350) {
83
		write_byte(nec_priv, INES_AUXD | INES_FOLLOWING_T1_350ns |
84
			   INES_INITIAL_T1_2000ns, AUXMR);
85
		retval = 350;
86
	} else {
87
		write_byte(nec_priv, INES_AUXD | INES_FOLLOWING_T1_500ns |
88
			   INES_INITIAL_T1_2000ns, AUXMR);
89
		retval = 500;
90
	}
91

92
	return retval;
93
}
94

95
static inline unsigned short num_in_fifo_bytes(struct ines_priv *ines_priv)
96
{
97
	return ines_inb(ines_priv, IN_FIFO_COUNT);
98
}
99

100
static ssize_t pio_read(struct gpib_board *board, struct ines_priv *ines_priv, u8 *buffer,
101
			size_t length, size_t *nbytes)
102
{
103
	ssize_t retval = 0;
104
	unsigned int num_fifo_bytes, i;
105
	struct nec7210_priv *nec_priv = &ines_priv->nec7210_priv;
106

107
	*nbytes = 0;
108
	while (*nbytes < length) {
109
		if (wait_event_interruptible(board->wait,
110
					     num_in_fifo_bytes(ines_priv) ||
111
					     test_bit(RECEIVED_END_BN, &nec_priv->state) ||
112
					     test_bit(DEV_CLEAR_BN, &nec_priv->state) ||
113
					     test_bit(TIMO_NUM, &board->status)))
114
			return -ERESTARTSYS;
115

116
		if (test_bit(TIMO_NUM, &board->status))
117
			return -ETIMEDOUT;
118
		if (test_bit(DEV_CLEAR_BN, &nec_priv->state))
119
			return -EINTR;
120

121
		num_fifo_bytes = num_in_fifo_bytes(ines_priv);
122
		if (num_fifo_bytes + *nbytes > length)
123
			num_fifo_bytes = length - *nbytes;
124

125
		for (i = 0; i < num_fifo_bytes; i++)
126
			buffer[(*nbytes)++] = read_byte(nec_priv, DIR);
127
		if (test_bit(RECEIVED_END_BN, &nec_priv->state) &&
128
		    num_in_fifo_bytes(ines_priv) == 0)
129
			break;
130
		if (need_resched())
131
			schedule();
132
	}
133
	/* make sure RECEIVED_END is in sync */
134
	ines_interrupt(board);
135
	return retval;
136
}
137

138
static int ines_accel_read(struct gpib_board *board, u8 *buffer,
139
			   size_t length, int *end, size_t *bytes_read)
140
{
141
	ssize_t retval = 0;
142
	struct ines_priv *ines_priv = board->private_data;
143
	struct nec7210_priv *nec_priv = &ines_priv->nec7210_priv;
144
	int counter_setting;
145

146
	*end = 0;
147
	*bytes_read = 0;
148
	if (length == 0)
149
		return 0;
150

151
	clear_bit(DEV_CLEAR_BN, &nec_priv->state);
152

153
	write_byte(nec_priv, INES_RFD_HLD_IMMEDIATE, AUXMR);
154

155
	// clear in fifo
156
	nec7210_set_reg_bits(nec_priv, ADMR, IN_FIFO_ENABLE_BIT, 0);
157
	nec7210_set_reg_bits(nec_priv, ADMR, IN_FIFO_ENABLE_BIT, IN_FIFO_ENABLE_BIT);
158

159
	ines_priv->extend_mode_bits |= LAST_BYTE_HANDLING_BIT;
160
	ines_priv->extend_mode_bits &= ~XFER_COUNTER_OUTPUT_BIT & ~XFER_COUNTER_ENABLE_BIT;
161
	ines_outb(ines_priv, ines_priv->extend_mode_bits, EXTEND_MODE);
162

163
	counter_setting = length - num_in_fifo_bytes(ines_priv);
164
	if (counter_setting > 0) {
165
		ines_set_xfer_counter(ines_priv, length);
166
		ines_priv->extend_mode_bits |= XFER_COUNTER_ENABLE_BIT;
167
		ines_outb(ines_priv, ines_priv->extend_mode_bits, EXTEND_MODE);
168

169
		// holdoff on END
170
		nec7210_set_handshake_mode(board, nec_priv, HR_HLDE);
171
		/* release rfd holdoff */
172
		write_byte(nec_priv, AUX_FH, AUXMR);
173
	}
174

175
	retval = pio_read(board, ines_priv, buffer, length, bytes_read);
176
	ines_priv->extend_mode_bits &= ~XFER_COUNTER_ENABLE_BIT;
177
	ines_outb(ines_priv, ines_priv->extend_mode_bits, EXTEND_MODE);
178
	if (retval < 0)	{
179
		write_byte(nec_priv, INES_RFD_HLD_IMMEDIATE, AUXMR);
180
		return retval;
181
	}
182
	if (test_and_clear_bit(RECEIVED_END_BN, &nec_priv->state))
183
		*end = 1;
184

185
	return retval;
186
}
187

188
static const int out_fifo_size = 0xff;
189

190
static inline unsigned short num_out_fifo_bytes(struct ines_priv *ines_priv)
191
{
192
	return ines_inb(ines_priv, OUT_FIFO_COUNT);
193
}
194

195
static int ines_write_wait(struct gpib_board *board, struct ines_priv *ines_priv,
196
			   unsigned int fifo_threshold)
197
{
198
	struct nec7210_priv *nec_priv = &ines_priv->nec7210_priv;
199

200
	// wait until byte is ready to be sent
201
	if (wait_event_interruptible(board->wait,
202
				     num_out_fifo_bytes(ines_priv) < fifo_threshold ||
203
				     test_bit(BUS_ERROR_BN, &nec_priv->state) ||
204
				     test_bit(DEV_CLEAR_BN, &nec_priv->state) ||
205
				     test_bit(TIMO_NUM, &board->status)))
206
		return -ERESTARTSYS;
207

208
	if (test_bit(BUS_ERROR_BN, &nec_priv->state))
209
		return -EIO;
210
	if (test_bit(DEV_CLEAR_BN, &nec_priv->state))
211
		return -EINTR;
212
	if (test_bit(TIMO_NUM, &board->status))
213
		return -ETIMEDOUT;
214

215
	return 0;
216
}
217

218
static int ines_accel_write(struct gpib_board *board, u8 *buffer, size_t length,
219
			    int send_eoi, size_t *bytes_written)
220
{
221
	size_t count = 0;
222
	ssize_t retval = 0;
223
	struct ines_priv *ines_priv = board->private_data;
224
	struct nec7210_priv *nec_priv = &ines_priv->nec7210_priv;
225
	unsigned int num_bytes, i;
226

227
	*bytes_written = 0;
228
	// clear out fifo
229
	nec7210_set_reg_bits(nec_priv, ADMR, OUT_FIFO_ENABLE_BIT, 0);
230
	nec7210_set_reg_bits(nec_priv, ADMR, OUT_FIFO_ENABLE_BIT, OUT_FIFO_ENABLE_BIT);
231

232
	ines_priv->extend_mode_bits |= XFER_COUNTER_OUTPUT_BIT;
233
	ines_priv->extend_mode_bits &= ~XFER_COUNTER_ENABLE_BIT;
234
	ines_priv->extend_mode_bits &= ~LAST_BYTE_HANDLING_BIT;
235
	ines_outb(ines_priv, ines_priv->extend_mode_bits, EXTEND_MODE);
236

237
	ines_set_xfer_counter(ines_priv, length);
238
	if (send_eoi)
239
		ines_priv->extend_mode_bits |= LAST_BYTE_HANDLING_BIT;
240
	ines_priv->extend_mode_bits |= XFER_COUNTER_ENABLE_BIT;
241
	ines_outb(ines_priv, ines_priv->extend_mode_bits, EXTEND_MODE);
242

243
	while (count < length) {
244
		retval = ines_write_wait(board, ines_priv, out_fifo_size);
245
		if (retval < 0)
246
			break;
247

248
		num_bytes = out_fifo_size - num_out_fifo_bytes(ines_priv);
249
		if (num_bytes + count > length)
250
			num_bytes = length - count;
251
		for (i = 0; i < num_bytes; i++)
252
			write_byte(nec_priv, buffer[count++], CDOR);
253
	}
254
	if (retval < 0)	{
255
		ines_priv->extend_mode_bits &= ~XFER_COUNTER_ENABLE_BIT;
256
		ines_outb(ines_priv, ines_priv->extend_mode_bits, EXTEND_MODE);
257
		*bytes_written = length - num_out_fifo_bytes(ines_priv);
258
		return retval;
259
	}
260
	// wait last byte has been sent
261
	retval = ines_write_wait(board, ines_priv, 1);
262
	ines_priv->extend_mode_bits &= ~XFER_COUNTER_ENABLE_BIT;
263
	ines_outb(ines_priv, ines_priv->extend_mode_bits, EXTEND_MODE);
264
	*bytes_written = length - num_out_fifo_bytes(ines_priv);
265

266
	return retval;
267
}
268

269
static irqreturn_t ines_pci_interrupt(int irq, void *arg)
270
{
271
	struct gpib_board *board = arg;
272
	struct ines_priv *priv = board->private_data;
273
	struct nec7210_priv *nec_priv = &priv->nec7210_priv;
274

275
	if (priv->pci_chip_type == PCI_CHIP_QUANCOM) {
276
		if ((inb(nec_priv->iobase +
277
			 QUANCOM_IRQ_CONTROL_STATUS_REG) &
278
		     QUANCOM_IRQ_ASSERTED_BIT))
279
			outb(QUANCOM_IRQ_ENABLE_BIT, nec_priv->iobase +
280
			     QUANCOM_IRQ_CONTROL_STATUS_REG);
281
	}
282

283
	return ines_interrupt(board);
284
}
285

286
static irqreturn_t ines_interrupt(struct gpib_board *board)
287
{
288
	struct ines_priv *priv = board->private_data;
289
	struct nec7210_priv *nec_priv = &priv->nec7210_priv;
290
	unsigned int isr3_bits, isr4_bits;
291
	unsigned long flags;
292
	int wake = 0;
293

294
	spin_lock_irqsave(&board->spinlock, flags);
295

296
	nec7210_interrupt(board, nec_priv);
297
	isr3_bits = ines_inb(priv, ISR3);
298
	isr4_bits = ines_inb(priv, ISR4);
299
	if (isr3_bits & IFC_ACTIVE_BIT)	{
300
		push_gpib_event(board, EVENT_IFC);
301
		wake++;
302
	}
303
	if (isr3_bits & FIFO_ERROR_BIT)
304
		dev_err(board->gpib_dev, "fifo error\n");
305
	if (isr3_bits & XFER_COUNT_BIT)
306
		wake++;
307

308
	if (isr4_bits & (IN_FIFO_WATERMARK_BIT | IN_FIFO_FULL_BIT | OUT_FIFO_WATERMARK_BIT |
309
			 OUT_FIFO_EMPTY_BIT))
310
		wake++;
311

312
	if (wake)
313
		wake_up_interruptible(&board->wait);
314
	spin_unlock_irqrestore(&board->spinlock, flags);
315
	return IRQ_HANDLED;
316
}
317

318
static int ines_pci_attach(struct gpib_board *board, const struct gpib_board_config *config);
319
static int ines_pci_accel_attach(struct gpib_board *board, const struct gpib_board_config *config);
320
static int ines_isa_attach(struct gpib_board *board, const struct gpib_board_config *config);
321

322
static void ines_pci_detach(struct gpib_board *board);
323
static void ines_isa_detach(struct gpib_board *board);
324

325
enum ines_pci_vendor_ids {
326
	PCI_VENDOR_ID_INES_QUICKLOGIC = 0x16da
327
};
328

329
enum ines_pci_device_ids {
330
	PCI_DEVICE_ID_INES_GPIB_AMCC = 0x8507,
331
	PCI_DEVICE_ID_INES_GPIB_QL5030 = 0x11,
332
};
333

334
enum ines_pci_subdevice_ids {
335
	PCI_SUBDEVICE_ID_INES_GPIB = 0x1072
336
};
337

338
static struct pci_device_id ines_pci_table[] = {
339
	{PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050, PCI_VENDOR_ID_PLX,
340
	 PCI_SUBDEVICE_ID_INES_GPIB, 0, 0, 0},
341
	{PCI_VENDOR_ID_AMCC, PCI_DEVICE_ID_INES_GPIB_AMCC, PCI_VENDOR_ID_AMCC,
342
	 PCI_SUBDEVICE_ID_INES_GPIB, 0, 0, 0},
343
	{PCI_VENDOR_ID_INES_QUICKLOGIC, PCI_DEVICE_ID_INES_GPIB_QL5030,
344
	 PCI_VENDOR_ID_INES_QUICKLOGIC, PCI_DEVICE_ID_INES_GPIB_QL5030, 0, 0, 0},
345
	{PCI_DEVICE(PCI_VENDOR_ID_QUANCOM, PCI_DEVICE_ID_QUANCOM_GPIB)},
346
	{0}
347
};
348
MODULE_DEVICE_TABLE(pci, ines_pci_table);
349

350
struct ines_pci_id {
351
	unsigned int vendor_id;
352
	unsigned int device_id;
353
	int subsystem_vendor_id;
354
	int subsystem_device_id;
355
	unsigned int gpib_region;
356
	unsigned int io_offset;
357
	enum ines_pci_chip pci_chip_type;
358
};
359

360
static struct ines_pci_id pci_ids[] = {
361
	{.vendor_id = PCI_VENDOR_ID_PLX,
362
	 .device_id = PCI_DEVICE_ID_PLX_9050,
363
	 .subsystem_vendor_id = PCI_VENDOR_ID_PLX,
364
	 .subsystem_device_id = PCI_SUBDEVICE_ID_INES_GPIB,
365
	 .gpib_region = 2,
366
	 .io_offset = 1,
367
	 .pci_chip_type = PCI_CHIP_PLX9050,
368
	},
369
	{.vendor_id = PCI_VENDOR_ID_AMCC,
370
	 .device_id = PCI_DEVICE_ID_INES_GPIB_AMCC,
371
	 .subsystem_vendor_id = PCI_VENDOR_ID_AMCC,
372
	 .subsystem_device_id = PCI_SUBDEVICE_ID_INES_GPIB,
373
	 .gpib_region = 1,
374
	 .io_offset = 1,
375
	 .pci_chip_type = PCI_CHIP_AMCC5920,
376
	},
377
	{.vendor_id = PCI_VENDOR_ID_INES_QUICKLOGIC,
378
	 .device_id = PCI_DEVICE_ID_INES_GPIB_QL5030,
379
	 .subsystem_vendor_id = PCI_VENDOR_ID_INES_QUICKLOGIC,
380
	 .subsystem_device_id = PCI_DEVICE_ID_INES_GPIB_QL5030,
381
	 .gpib_region = 1,
382
	 .io_offset = 1,
383
	 .pci_chip_type = PCI_CHIP_QUICKLOGIC5030,
384
	},
385
	{.vendor_id = PCI_VENDOR_ID_QUANCOM,
386
	 .device_id = PCI_DEVICE_ID_QUANCOM_GPIB,
387
	 .subsystem_vendor_id = -1,
388
	 .subsystem_device_id = -1,
389
	 .gpib_region = 0,
390
	 .io_offset = 4,
391
	 .pci_chip_type = PCI_CHIP_QUANCOM,
392
	},
393
};
394

395
static const int num_pci_chips = ARRAY_SIZE(pci_ids);
396

397
// wrappers for interface functions
398
static int ines_read(struct gpib_board *board, u8 *buffer, size_t length,
399
		     int *end, size_t *bytes_read)
400
{
401
	struct ines_priv *priv = board->private_data;
402
	struct nec7210_priv *nec_priv = &priv->nec7210_priv;
403
	ssize_t retval;
404
	int dummy;
405

406
	retval = nec7210_read(board, &priv->nec7210_priv, buffer, length, end, bytes_read);
407
	if (retval < 0)	{
408
		write_byte(nec_priv, INES_RFD_HLD_IMMEDIATE, AUXMR);
409

410
		set_bit(RFD_HOLDOFF_BN, &nec_priv->state);
411

412
		nec7210_read_data_in(board, nec_priv, &dummy);
413
	}
414
	return retval;
415
}
416

417
static int ines_write(struct gpib_board *board, u8 *buffer, size_t length, int send_eoi,
418
		      size_t *bytes_written)
419
{
420
	struct ines_priv *priv = board->private_data;
421

422
	return nec7210_write(board, &priv->nec7210_priv, buffer, length, send_eoi, bytes_written);
423
}
424

425
static int ines_command(struct gpib_board *board, u8 *buffer, size_t length, size_t *bytes_written)
426
{
427
	struct ines_priv *priv = board->private_data;
428

429
	return nec7210_command(board, &priv->nec7210_priv, buffer, length, bytes_written);
430
}
431

432
static int ines_take_control(struct gpib_board *board, int synchronous)
433
{
434
	struct ines_priv *priv = board->private_data;
435

436
	return nec7210_take_control(board, &priv->nec7210_priv, synchronous);
437
}
438

439
static int ines_go_to_standby(struct gpib_board *board)
440
{
441
	struct ines_priv *priv = board->private_data;
442

443
	return nec7210_go_to_standby(board, &priv->nec7210_priv);
444
}
445

446
static int ines_request_system_control(struct gpib_board *board, int request_control)
447
{
448
	struct ines_priv *priv = board->private_data;
449

450
	return nec7210_request_system_control(board, &priv->nec7210_priv, request_control);
451
}
452

453
static void ines_interface_clear(struct gpib_board *board, int assert)
454
{
455
	struct ines_priv *priv = board->private_data;
456

457
	nec7210_interface_clear(board, &priv->nec7210_priv, assert);
458
}
459

460
static void ines_remote_enable(struct gpib_board *board, int enable)
461
{
462
	struct ines_priv *priv = board->private_data;
463

464
	nec7210_remote_enable(board, &priv->nec7210_priv, enable);
465
}
466

467
static int ines_enable_eos(struct gpib_board *board, u8 eos_byte, int compare_8_bits)
468
{
469
	struct ines_priv *priv = board->private_data;
470

471
	return nec7210_enable_eos(board, &priv->nec7210_priv, eos_byte, compare_8_bits);
472
}
473

474
static void ines_disable_eos(struct gpib_board *board)
475
{
476
	struct ines_priv *priv = board->private_data;
477

478
	nec7210_disable_eos(board, &priv->nec7210_priv);
479
}
480

481
static unsigned int ines_update_status(struct gpib_board *board, unsigned int clear_mask)
482
{
483
	struct ines_priv *priv = board->private_data;
484

485
	return nec7210_update_status(board, &priv->nec7210_priv, clear_mask);
486
}
487

488
static int ines_primary_address(struct gpib_board *board, unsigned int address)
489
{
490
	struct ines_priv *priv = board->private_data;
491

492
	return nec7210_primary_address(board, &priv->nec7210_priv, address);
493
}
494

495
static int ines_secondary_address(struct gpib_board *board, unsigned int address, int enable)
496
{
497
	struct ines_priv *priv = board->private_data;
498

499
	return nec7210_secondary_address(board, &priv->nec7210_priv, address, enable);
500
}
501

502
static int ines_parallel_poll(struct gpib_board *board, u8 *result)
503
{
504
	struct ines_priv *priv = board->private_data;
505

506
	return nec7210_parallel_poll(board, &priv->nec7210_priv, result);
507
}
508

509
static void ines_parallel_poll_configure(struct gpib_board *board, u8 config)
510
{
511
	struct ines_priv *priv = board->private_data;
512

513
	nec7210_parallel_poll_configure(board, &priv->nec7210_priv, config);
514
}
515

516
static void ines_parallel_poll_response(struct gpib_board *board, int ist)
517
{
518
	struct ines_priv *priv = board->private_data;
519

520
	nec7210_parallel_poll_response(board, &priv->nec7210_priv, ist);
521
}
522

523
static void ines_serial_poll_response(struct gpib_board *board, u8 status)
524
{
525
	struct ines_priv *priv = board->private_data;
526

527
	nec7210_serial_poll_response(board, &priv->nec7210_priv, status);
528
}
529

530
static u8 ines_serial_poll_status(struct gpib_board *board)
531
{
532
	struct ines_priv *priv = board->private_data;
533

534
	return nec7210_serial_poll_status(board, &priv->nec7210_priv);
535
}
536

537
static void ines_return_to_local(struct gpib_board *board)
538
{
539
	struct ines_priv *priv = board->private_data;
540

541
	nec7210_return_to_local(board, &priv->nec7210_priv);
542
}
543

544
static struct gpib_interface ines_pci_unaccel_interface = {
545
	.name = "ines_pci_unaccel",
546
	.attach = ines_pci_attach,
547
	.detach = ines_pci_detach,
548
	.read = ines_read,
549
	.write = ines_write,
550
	.command = ines_command,
551
	.take_control = ines_take_control,
552
	.go_to_standby = ines_go_to_standby,
553
	.request_system_control = ines_request_system_control,
554
	.interface_clear = ines_interface_clear,
555
	.remote_enable = ines_remote_enable,
556
	.enable_eos = ines_enable_eos,
557
	.disable_eos = ines_disable_eos,
558
	.parallel_poll = ines_parallel_poll,
559
	.parallel_poll_configure = ines_parallel_poll_configure,
560
	.parallel_poll_response = ines_parallel_poll_response,
561
	.local_parallel_poll_mode = NULL, // XXX
562
	.line_status = ines_line_status,
563
	.update_status = ines_update_status,
564
	.primary_address = ines_primary_address,
565
	.secondary_address = ines_secondary_address,
566
	.serial_poll_response = ines_serial_poll_response,
567
	.serial_poll_status = ines_serial_poll_status,
568
	.t1_delay = ines_t1_delay,
569
	.return_to_local = ines_return_to_local,
570
};
571

572
static struct gpib_interface ines_pci_interface = {
573
	.name = "ines_pci",
574
	.attach = ines_pci_accel_attach,
575
	.detach = ines_pci_detach,
576
	.read = ines_accel_read,
577
	.write = ines_accel_write,
578
	.command = ines_command,
579
	.take_control = ines_take_control,
580
	.go_to_standby = ines_go_to_standby,
581
	.request_system_control = ines_request_system_control,
582
	.interface_clear = ines_interface_clear,
583
	.remote_enable = ines_remote_enable,
584
	.enable_eos = ines_enable_eos,
585
	.disable_eos = ines_disable_eos,
586
	.parallel_poll = ines_parallel_poll,
587
	.parallel_poll_configure = ines_parallel_poll_configure,
588
	.parallel_poll_response = ines_parallel_poll_response,
589
	.local_parallel_poll_mode = NULL, // XXX
590
	.line_status = ines_line_status,
591
	.update_status = ines_update_status,
592
	.primary_address = ines_primary_address,
593
	.secondary_address = ines_secondary_address,
594
	.serial_poll_response = ines_serial_poll_response,
595
	.serial_poll_status = ines_serial_poll_status,
596
	.t1_delay = ines_t1_delay,
597
	.return_to_local = ines_return_to_local,
598
};
599

600
static struct gpib_interface ines_pci_accel_interface = {
601
	.name = "ines_pci_accel",
602
	.attach = ines_pci_accel_attach,
603
	.detach = ines_pci_detach,
604
	.read = ines_accel_read,
605
	.write = ines_accel_write,
606
	.command = ines_command,
607
	.take_control = ines_take_control,
608
	.go_to_standby = ines_go_to_standby,
609
	.request_system_control = ines_request_system_control,
610
	.interface_clear = ines_interface_clear,
611
	.remote_enable = ines_remote_enable,
612
	.enable_eos = ines_enable_eos,
613
	.disable_eos = ines_disable_eos,
614
	.parallel_poll = ines_parallel_poll,
615
	.parallel_poll_configure = ines_parallel_poll_configure,
616
	.parallel_poll_response = ines_parallel_poll_response,
617
	.local_parallel_poll_mode = NULL, // XXX
618
	.line_status = ines_line_status,
619
	.update_status = ines_update_status,
620
	.primary_address = ines_primary_address,
621
	.secondary_address = ines_secondary_address,
622
	.serial_poll_response = ines_serial_poll_response,
623
	.serial_poll_status = ines_serial_poll_status,
624
	.t1_delay = ines_t1_delay,
625
	.return_to_local = ines_return_to_local,
626
};
627

628
static struct gpib_interface ines_isa_interface = {
629
	.name = "ines_isa",
630
	.attach = ines_isa_attach,
631
	.detach = ines_isa_detach,
632
	.read = ines_accel_read,
633
	.write = ines_accel_write,
634
	.command = ines_command,
635
	.take_control = ines_take_control,
636
	.go_to_standby = ines_go_to_standby,
637
	.request_system_control = ines_request_system_control,
638
	.interface_clear = ines_interface_clear,
639
	.remote_enable = ines_remote_enable,
640
	.enable_eos = ines_enable_eos,
641
	.disable_eos = ines_disable_eos,
642
	.parallel_poll = ines_parallel_poll,
643
	.parallel_poll_configure = ines_parallel_poll_configure,
644
	.parallel_poll_response = ines_parallel_poll_response,
645
	.local_parallel_poll_mode = NULL, // XXX
646
	.line_status = ines_line_status,
647
	.update_status = ines_update_status,
648
	.primary_address = ines_primary_address,
649
	.secondary_address = ines_secondary_address,
650
	.serial_poll_response = ines_serial_poll_response,
651
	.serial_poll_status = ines_serial_poll_status,
652
	.t1_delay = ines_t1_delay,
653
	.return_to_local = ines_return_to_local,
654
};
655

656
static int ines_allocate_private(struct gpib_board *board)
657
{
658
	struct ines_priv *priv;
659

660
	board->private_data = kzalloc_obj(struct ines_priv);
661
	if (!board->private_data)
662
		return -ENOMEM;
663
	priv = board->private_data;
664
	init_nec7210_private(&priv->nec7210_priv);
665
	return 0;
666
}
667

668
static void ines_free_private(struct gpib_board *board)
669
{
670
	kfree(board->private_data);
671
	board->private_data = NULL;
672
}
673

674
static int ines_generic_attach(struct gpib_board *board)
675
{
676
	struct ines_priv *ines_priv;
677
	struct nec7210_priv *nec_priv;
678
	int retval;
679

680
	board->status = 0;
681

682
	retval = ines_allocate_private(board);
683
	if (retval)
684
		return retval;
685
	ines_priv = board->private_data;
686
	nec_priv = &ines_priv->nec7210_priv;
687
	nec_priv->read_byte = nec7210_ioport_read_byte;
688
	nec_priv->write_byte = nec7210_ioport_write_byte;
689
	nec_priv->offset = 1;
690
	nec_priv->type = IGPIB7210;
691
	ines_priv->pci_chip_type = PCI_CHIP_NONE;
692

693
	return 0;
694
}
695

696
static void ines_online(struct ines_priv *ines_priv, const struct gpib_board *board, int use_accel)
697
{
698
	struct nec7210_priv *nec_priv = &ines_priv->nec7210_priv;
699

700
	/* ines doesn't seem to use internal count register */
701
	write_byte(nec_priv, ICR | 0, AUXMR);
702

703
	write_byte(nec_priv, INES_AUX_XMODE, AUXMR);
704
	write_byte(nec_priv, INES_RFD_HLD_IMMEDIATE, AUXMR);
705

706
	set_bit(RFD_HOLDOFF_BN, &nec_priv->state);
707

708
	write_byte(nec_priv, INES_AUXD | 0, AUXMR);
709
	ines_outb(ines_priv, 0, XDMA_CONTROL);
710
	ines_priv->extend_mode_bits = 0;
711
	ines_outb(ines_priv, ines_priv->extend_mode_bits, EXTEND_MODE);
712
	if (use_accel) {
713
		ines_outb(ines_priv, 0x80, OUT_FIFO_WATERMARK);
714
		ines_outb(ines_priv, 0x80, IN_FIFO_WATERMARK);
715
		ines_outb(ines_priv, IFC_ACTIVE_BIT | ATN_ACTIVE_BIT |
716
			  FIFO_ERROR_BIT | XFER_COUNT_BIT, IMR3);
717
		ines_outb(ines_priv, IN_FIFO_WATERMARK_BIT | IN_FIFO_FULL_BIT |
718
			  OUT_FIFO_WATERMARK_BIT | OUT_FIFO_EMPTY_BIT, IMR4);
719
	} else {
720
		nec7210_set_reg_bits(nec_priv, ADMR, IN_FIFO_ENABLE_BIT | OUT_FIFO_ENABLE_BIT, 0);
721
		ines_outb(ines_priv, IFC_ACTIVE_BIT | FIFO_ERROR_BIT, IMR3);
722
		ines_outb(ines_priv, 0, IMR4);
723
	}
724

725
	nec7210_board_online(nec_priv, board);
726
	if (use_accel)
727
		nec7210_set_reg_bits(nec_priv, IMR1, HR_DOIE | HR_DIIE, 0);
728
}
729

730
static int ines_common_pci_attach(struct gpib_board *board, const struct gpib_board_config *config)
731
{
732
	struct ines_priv *ines_priv;
733
	struct nec7210_priv *nec_priv;
734
	int isr_flags = 0;
735
	int retval;
736
	struct ines_pci_id found_id;
737
	unsigned int i;
738
	struct pci_dev *pdev;
739

740
	memset(&found_id, 0, sizeof(found_id));
741

742
	retval = ines_generic_attach(board);
743
	if (retval)
744
		return retval;
745

746
	ines_priv = board->private_data;
747
	nec_priv = &ines_priv->nec7210_priv;
748

749
	// find board
750
	ines_priv->pci_device = NULL;
751
	for (i = 0; i < num_pci_chips && !ines_priv->pci_device; i++) {
752
		pdev = NULL;
753
		do {
754
			if (pci_ids[i].subsystem_vendor_id >= 0 &&
755
			    pci_ids[i].subsystem_device_id >= 0)
756
				pdev = pci_get_subsys(pci_ids[i].vendor_id, pci_ids[i].device_id,
757
						      pci_ids[i].subsystem_vendor_id,
758
						      pci_ids[i].subsystem_device_id, pdev);
759
			else
760
				pdev = pci_get_device(pci_ids[i].vendor_id, pci_ids[i].device_id,
761
						      pdev);
762
			if (!pdev)
763
				break;
764
			if (config->pci_bus >= 0 && config->pci_bus != pdev->bus->number)
765
				continue;
766
			if (config->pci_slot >= 0 && config->pci_slot != PCI_SLOT(pdev->devfn))
767
				continue;
768
			found_id = pci_ids[i];
769
			ines_priv->pci_device = pdev;
770
			break;
771
		} while (1);
772
	}
773
	if (!ines_priv->pci_device) {
774
		dev_err(board->gpib_dev, "could not find ines PCI board\n");
775
		return -1;
776
	}
777

778
	if (pci_enable_device(ines_priv->pci_device)) {
779
		dev_err(board->gpib_dev, "error enabling pci device\n");
780
		return -1;
781
	}
782

783
	if (pci_request_regions(ines_priv->pci_device, DRV_NAME))
784
		return -1;
785
	nec_priv->iobase = pci_resource_start(ines_priv->pci_device,
786
					      found_id.gpib_region);
787

788
	ines_priv->pci_chip_type = found_id.pci_chip_type;
789
	nec_priv->offset = found_id.io_offset;
790
	switch (ines_priv->pci_chip_type) {
791
	case PCI_CHIP_PLX9050:
792
		ines_priv->plx_iobase = pci_resource_start(ines_priv->pci_device, 1);
793
		break;
794
	case PCI_CHIP_AMCC5920:
795
		ines_priv->amcc_iobase = pci_resource_start(ines_priv->pci_device, 0);
796
		break;
797
	case PCI_CHIP_QUANCOM:
798
		break;
799
	case PCI_CHIP_QUICKLOGIC5030:
800
		break;
801
	default:
802
		dev_err(board->gpib_dev, "unspecified chip type? (bug)\n");
803
		nec_priv->iobase = 0;
804
		pci_release_regions(ines_priv->pci_device);
805
		return -1;
806
	}
807

808
	nec7210_board_reset(nec_priv, board);
809
#ifdef QUANCOM_PCI
810
	if (ines_priv->pci_chip_type == PCI_CHIP_QUANCOM) {
811
		/* change interrupt polarity */
812
		nec_priv->auxb_bits |= HR_INV;
813
		ines_outb(ines_priv, nec_priv->auxb_bits, AUXMR);
814
	}
815
#endif
816
	isr_flags |= IRQF_SHARED;
817
	if (request_irq(ines_priv->pci_device->irq, ines_pci_interrupt, isr_flags,
818
			DRV_NAME, board)) {
819
		dev_err(board->gpib_dev, "can't request IRQ %d\n", ines_priv->pci_device->irq);
820
		return -1;
821
	}
822
	ines_priv->irq = ines_priv->pci_device->irq;
823

824
	// enable interrupts on pci chip
825
	switch (ines_priv->pci_chip_type) {
826
	case PCI_CHIP_PLX9050:
827
		outl(PLX9050_LINTR1_EN_BIT | PLX9050_LINTR1_POLARITY_BIT | PLX9050_PCI_INTR_EN_BIT,
828
		     ines_priv->plx_iobase + PLX9050_INTCSR_REG);
829
		break;
830
	case PCI_CHIP_AMCC5920:
831
	{
832
		static const int region = 1;
833
		static const int num_wait_states = 7;
834
		u32 bits;
835

836
		bits = amcc_prefetch_bits(region, PREFETCH_DISABLED);
837
		bits |= amcc_PTADR_mode_bit(region);
838
		bits |= amcc_disable_write_fifo_bit(region);
839
		bits |= amcc_wait_state_bits(region, num_wait_states);
840
		outl(bits, ines_priv->amcc_iobase + AMCC_PASS_THRU_REG);
841
		outl(AMCC_ADDON_INTR_ENABLE_BIT, ines_priv->amcc_iobase + AMCC_INTCS_REG);
842
	}
843
	break;
844
	case PCI_CHIP_QUANCOM:
845
		outb(QUANCOM_IRQ_ENABLE_BIT, nec_priv->iobase +
846
		     QUANCOM_IRQ_CONTROL_STATUS_REG);
847
		break;
848
	case PCI_CHIP_QUICKLOGIC5030:
849
		break;
850
	default:
851
		dev_err(board->gpib_dev, "unspecified chip type? (bug)\n");
852
		return -1;
853
	}
854

855
	return 0;
856
}
857

858
static int ines_pci_attach(struct gpib_board *board, const struct gpib_board_config *config)
859
{
860
	struct ines_priv *ines_priv;
861
	int retval;
862

863
	retval = ines_common_pci_attach(board, config);
864
	if (retval < 0)
865
		return retval;
866

867
	ines_priv = board->private_data;
868
	ines_online(ines_priv, board, 0);
869

870
	return 0;
871
}
872

873
static int ines_pci_accel_attach(struct gpib_board *board, const struct gpib_board_config *config)
874
{
875
	struct ines_priv *ines_priv;
876
	int retval;
877

878
	retval = ines_common_pci_attach(board, config);
879
	if (retval < 0)
880
		return retval;
881

882
	ines_priv = board->private_data;
883
	ines_online(ines_priv, board, 1);
884

885
	return 0;
886
}
887

888
static const int ines_isa_iosize = 0x20;
889

890
static int ines_isa_attach(struct gpib_board *board, const struct gpib_board_config *config)
891
{
892
	struct ines_priv *ines_priv;
893
	struct nec7210_priv *nec_priv;
894
	int isr_flags = 0;
895
	int retval;
896

897
	retval = ines_generic_attach(board);
898
	if (retval)
899
		return retval;
900

901
	ines_priv = board->private_data;
902
	nec_priv = &ines_priv->nec7210_priv;
903

904
	if (!request_region(config->ibbase, ines_isa_iosize, DRV_NAME)) {
905
		dev_err(board->gpib_dev, "ioports at 0x%x already in use\n",
906
			config->ibbase);
907
		return -EBUSY;
908
	}
909
	nec_priv->iobase = config->ibbase;
910
	nec_priv->offset = 1;
911
	nec7210_board_reset(nec_priv, board);
912
	if (request_irq(config->ibirq, ines_pci_interrupt, isr_flags, DRV_NAME, board)) {
913
		dev_err(board->gpib_dev, "failed to allocate IRQ %d\n", config->ibirq);
914
		return -1;
915
	}
916
	ines_priv->irq = config->ibirq;
917
	ines_online(ines_priv, board, 1);
918
	return 0;
919
}
920

921
static void ines_pci_detach(struct gpib_board *board)
922
{
923
	struct ines_priv *ines_priv = board->private_data;
924
	struct nec7210_priv *nec_priv;
925

926
	if (ines_priv) {
927
		nec_priv = &ines_priv->nec7210_priv;
928
		if (ines_priv->irq) {
929
			// disable interrupts
930
			switch (ines_priv->pci_chip_type) {
931
			case PCI_CHIP_AMCC5920:
932
				if (ines_priv->plx_iobase)
933
					outl(0, ines_priv->plx_iobase + PLX9050_INTCSR_REG);
934
				break;
935
			case PCI_CHIP_QUANCOM:
936
				if (nec_priv->iobase)
937
					outb(0, nec_priv->iobase +
938
					     QUANCOM_IRQ_CONTROL_STATUS_REG);
939
				break;
940
			default:
941
				break;
942
			}
943
			free_irq(ines_priv->irq, board);
944
		}
945
		if (nec_priv->iobase) {
946
			nec7210_board_reset(nec_priv, board);
947
			pci_release_regions(ines_priv->pci_device);
948
		}
949
		if (ines_priv->pci_device)
950
			pci_dev_put(ines_priv->pci_device);
951
	}
952
	ines_free_private(board);
953
}
954

955
static void ines_isa_detach(struct gpib_board *board)
956
{
957
	struct ines_priv *ines_priv = board->private_data;
958
	struct nec7210_priv *nec_priv;
959

960
	if (ines_priv) {
961
		nec_priv = &ines_priv->nec7210_priv;
962
		if (ines_priv->irq)
963
			free_irq(ines_priv->irq, board);
964
		if (nec_priv->iobase) {
965
			nec7210_board_reset(nec_priv, board);
966
			release_region(nec_priv->iobase, ines_isa_iosize);
967
		}
968
	}
969
	ines_free_private(board);
970
}
971

972
static int ines_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
973
{
974
	return 0;
975
}
976

977
static struct pci_driver ines_pci_driver = {
978
	.name = "ines_gpib",
979
	.id_table = ines_pci_table,
980
	.probe = &ines_pci_probe
981
};
982

983
#ifdef CONFIG_GPIB_PCMCIA
984

985
#include <linux/kernel.h>
986
#include <linux/ptrace.h>
987
#include <linux/string.h>
988
#include <linux/timer.h>
989

990
#include <pcmcia/cistpl.h>
991
#include <pcmcia/ds.h>
992
#include <pcmcia/cisreg.h>
993

994
static const int ines_pcmcia_iosize = 0x20;
995

996
/*
997
 * The event() function is this driver's Card Services event handler.
998
 * It will be called by Card Services when an appropriate card status
999
 * event is received.  The config() and release() entry points are
1000
 * used to configure or release a socket, in response to card insertion
1001
 * and ejection events.  They are invoked from the gpib event
1002
 * handler.
1003
 */
1004

1005
static int ines_gpib_config(struct pcmcia_device  *link);
1006
static void ines_gpib_release(struct pcmcia_device  *link);
1007
static int ines_pcmcia_attach(struct gpib_board *board, const struct gpib_board_config *config);
1008
static int ines_pcmcia_accel_attach(struct gpib_board *board,
1009
				    const struct gpib_board_config *config);
1010
static void ines_pcmcia_detach(struct gpib_board *board);
1011
static int ines_common_pcmcia_attach(struct gpib_board *board);
1012
/*
1013
 * A linked list of "instances" of the gpib device.  Each actual
1014
 * PCMCIA card corresponds to one device instance, and is described
1015
 * by one dev_link_t structure (defined in ds.h).
1016
 *
1017
 * You may not want to use a linked list for this -- for example, the
1018
 * memory card driver uses an array of dev_link_t pointers, where minor
1019
 * device numbers are used to derive the corresponding array index.
1020
 */
1021

1022
static struct pcmcia_device *curr_dev;
1023

1024
/*
1025
 * A dev_link_t structure has fields for most things that are needed
1026
 * to keep track of a socket, but there will usually be some device
1027
 * specific information that also needs to be kept track of.  The
1028
 * 'priv' pointer in a dev_link_t structure can be used to point to
1029
 * a device-specific private data structure, like this.
1030
 *
1031
 * A driver needs to provide a dev_node_t structure for each device
1032
 * on a card.	In some cases, there is only one device per card (for
1033
 * example, ethernet cards, modems).  In other cases, there may be
1034
 * many actual or logical devices (SCSI adapters, memory cards with
1035
 * multiple partitions).  The dev_node_t structures need to be kept
1036
 * in a linked list starting at the 'dev' field of a dev_link_t
1037
 * structure.	We allocate them in the card's private data structure,
1038
 * because they generally can't be allocated dynamically.
1039
 */
1040

1041
struct local_info {
1042
	struct pcmcia_device	*p_dev;
1043
	struct gpib_board		*dev;
1044
	u_short manfid;
1045
	u_short cardid;
1046
};
1047

1048
/*
1049
 * gpib_attach() creates an "instance" of the driver, allocating
1050
 * local data structures for one device.  The device is registered
1051
 * with Card Services.
1052
 *
1053
 * The dev_link structure is initialized, but we don't actually
1054
 * configure the card at this point -- we wait until we receive a
1055
 * card insertion event.
1056
 */
1057
static int ines_gpib_probe(struct pcmcia_device *link)
1058
{
1059
	struct local_info *info;
1060

1061
//	int ret, i;
1062

1063
	/* Allocate space for private device-specific data */
1064
	info = kzalloc_obj(*info);
1065
	if (!info)
1066
		return -ENOMEM;
1067

1068
	info->p_dev = link;
1069
	link->priv = info;
1070

1071
	/* The io structure describes IO port mapping */
1072
	link->resource[0]->end = 32;
1073
	link->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
1074
	link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
1075
	link->io_lines = 5;
1076

1077
	/* General socket configuration */
1078
	link->config_flags = CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
1079

1080
	/* Register with Card Services */
1081
	curr_dev = link;
1082
	return ines_gpib_config(link);
1083
}
1084

1085
/*
1086
 * This deletes a driver "instance".	The device is de-registered
1087
 * with Card Services.  If it has been released, all local data
1088
 * structures are freed.  Otherwise, the structures will be freed
1089
 * when the device is released.
1090
 */
1091
static void ines_gpib_remove(struct pcmcia_device *link)
1092
{
1093
	struct local_info *info = link->priv;
1094
	//struct struct gpib_board *dev = info->dev;
1095

1096
	if (info->dev)
1097
		ines_pcmcia_detach(info->dev);
1098
	ines_gpib_release(link);
1099

1100
	//free_netdev(dev);
1101
	kfree(info);
1102
}
1103

1104
static int ines_gpib_config_iteration(struct pcmcia_device *link, void *priv_data)
1105
{
1106
	return pcmcia_request_io(link);
1107
}
1108

1109
/*
1110
 * gpib_config() is scheduled to run after a CARD_INSERTION event
1111
 * is received, to configure the PCMCIA socket, and to make the
1112
 * device available to the system.
1113
 */
1114
static int ines_gpib_config(struct pcmcia_device *link)
1115
{
1116
	int retval;
1117
	void __iomem *virt;
1118

1119
	retval = pcmcia_loop_config(link, &ines_gpib_config_iteration, NULL);
1120
	if (retval) {
1121
		dev_warn(&link->dev, "no configuration found\n");
1122
		ines_gpib_release(link);
1123
		return -ENODEV;
1124
	}
1125

1126
	dev_dbg(&link->dev, "ines_cs: manufacturer: 0x%x card: 0x%x\n",
1127
		link->manf_id, link->card_id);
1128

1129
	/*
1130
	 * for the ines card we have to setup the configuration registers in
1131
	 * attribute memory here
1132
	 */
1133
	link->resource[2]->flags |= WIN_MEMORY_TYPE_AM | WIN_DATA_WIDTH_8 | WIN_ENABLE;
1134
	link->resource[2]->end = 0x1000;
1135
	retval = pcmcia_request_window(link, link->resource[2], 250);
1136
	if (retval) {
1137
		dev_warn(&link->dev, "pcmcia_request_window failed\n");
1138
		ines_gpib_release(link);
1139
		return -ENODEV;
1140
	}
1141
	retval = pcmcia_map_mem_page(link, link->resource[2], 0);
1142
	if (retval) {
1143
		dev_warn(&link->dev, "pcmcia_map_mem_page failed\n");
1144
		ines_gpib_release(link);
1145
		return -ENODEV;
1146
	}
1147
	virt = ioremap(link->resource[2]->start, resource_size(link->resource[2]));
1148
	writeb((link->resource[2]->start >> 2) & 0xff, virt + 0xf0); // IOWindow base
1149
	iounmap(virt);
1150

1151
	/*
1152
	 * This actually configures the PCMCIA socket -- setting up
1153
	 * the I/O windows and the interrupt mapping.
1154
	 */
1155
	retval = pcmcia_enable_device(link);
1156
	if (retval) {
1157
		ines_gpib_release(link);
1158
		return -ENODEV;
1159
	}
1160
	return 0;
1161
} /* gpib_config */
1162

1163
/*
1164
 * After a card is removed, gpib_release() will unregister the net
1165
 * device, and release the PCMCIA configuration.  If the device is
1166
 * still open, this will be postponed until it is closed.
1167
 */
1168

1169
static void ines_gpib_release(struct pcmcia_device *link)
1170
{
1171
	pcmcia_disable_device(link);
1172
} /* gpib_release */
1173

1174
static int ines_gpib_suspend(struct pcmcia_device *link)
1175
{
1176
	//struct local_info *info = link->priv;
1177
	//struct struct gpib_board *dev = info->dev;
1178

1179
	if (link->open)
1180
		dev_err(&link->dev, "Device still open\n");
1181
	//netif_device_detach(dev);
1182

1183
	return 0;
1184
}
1185

1186
static int ines_gpib_resume(struct pcmcia_device *link)
1187
{
1188
	//struct local_info_t *info = link->priv;
1189
	//struct struct gpib_board *dev = info->dev;
1190

1191
	/*if (link->open) {
1192
	 *	ni_gpib_probe(dev);	/ really?
1193
	 *	//netif_device_attach(dev);
1194
	 *}
1195
	 */
1196
	return ines_gpib_config(link);
1197
}
1198

1199
static struct pcmcia_device_id ines_pcmcia_ids[] = {
1200
	PCMCIA_DEVICE_MANF_CARD(0x01b4, 0x4730),
1201
	PCMCIA_DEVICE_NULL
1202
};
1203
MODULE_DEVICE_TABLE(pcmcia, ines_pcmcia_ids);
1204

1205
static struct pcmcia_driver ines_gpib_cs_driver = {
1206
	.owner		= THIS_MODULE,
1207
	.name		= "ines_gpib_cs",
1208
	.id_table	= ines_pcmcia_ids,
1209
	.probe		= ines_gpib_probe,
1210
	.remove		= ines_gpib_remove,
1211
	.suspend	= ines_gpib_suspend,
1212
	.resume		= ines_gpib_resume,
1213
};
1214

1215
static void ines_pcmcia_cleanup_module(void)
1216
{
1217
	pcmcia_unregister_driver(&ines_gpib_cs_driver);
1218
}
1219

1220
static struct gpib_interface ines_pcmcia_unaccel_interface = {
1221
	.name = "ines_pcmcia_unaccel",
1222
	.attach = ines_pcmcia_attach,
1223
	.detach = ines_pcmcia_detach,
1224
	.read = ines_read,
1225
	.write = ines_write,
1226
	.command = ines_command,
1227
	.take_control = ines_take_control,
1228
	.go_to_standby = ines_go_to_standby,
1229
	.request_system_control = ines_request_system_control,
1230
	.interface_clear = ines_interface_clear,
1231
	.remote_enable = ines_remote_enable,
1232
	.enable_eos = ines_enable_eos,
1233
	.disable_eos = ines_disable_eos,
1234
	.parallel_poll = ines_parallel_poll,
1235
	.parallel_poll_configure = ines_parallel_poll_configure,
1236
	.parallel_poll_response = ines_parallel_poll_response,
1237
	.local_parallel_poll_mode = NULL, // XXX
1238
	.line_status = ines_line_status,
1239
	.update_status = ines_update_status,
1240
	.primary_address = ines_primary_address,
1241
	.secondary_address = ines_secondary_address,
1242
	.serial_poll_response = ines_serial_poll_response,
1243
	.serial_poll_status = ines_serial_poll_status,
1244
	.t1_delay = ines_t1_delay,
1245
	.return_to_local = ines_return_to_local,
1246
};
1247

1248
static struct gpib_interface ines_pcmcia_accel_interface = {
1249
	.name = "ines_pcmcia_accel",
1250
	.attach = ines_pcmcia_accel_attach,
1251
	.detach = ines_pcmcia_detach,
1252
	.read = ines_accel_read,
1253
	.write = ines_accel_write,
1254
	.command = ines_command,
1255
	.take_control = ines_take_control,
1256
	.go_to_standby = ines_go_to_standby,
1257
	.request_system_control = ines_request_system_control,
1258
	.interface_clear = ines_interface_clear,
1259
	.remote_enable = ines_remote_enable,
1260
	.enable_eos = ines_enable_eos,
1261
	.disable_eos = ines_disable_eos,
1262
	.parallel_poll = ines_parallel_poll,
1263
	.parallel_poll_configure = ines_parallel_poll_configure,
1264
	.parallel_poll_response = ines_parallel_poll_response,
1265
	.local_parallel_poll_mode = NULL, // XXX
1266
	.line_status = ines_line_status,
1267
	.update_status = ines_update_status,
1268
	.primary_address = ines_primary_address,
1269
	.secondary_address = ines_secondary_address,
1270
	.serial_poll_response = ines_serial_poll_response,
1271
	.serial_poll_status = ines_serial_poll_status,
1272
	.t1_delay = ines_t1_delay,
1273
	.return_to_local = ines_return_to_local,
1274
};
1275

1276
static struct gpib_interface ines_pcmcia_interface = {
1277
	.name = "ines_pcmcia",
1278
	.attach = ines_pcmcia_accel_attach,
1279
	.detach = ines_pcmcia_detach,
1280
	.read = ines_accel_read,
1281
	.write = ines_accel_write,
1282
	.command = ines_command,
1283
	.take_control = ines_take_control,
1284
	.go_to_standby = ines_go_to_standby,
1285
	.request_system_control = ines_request_system_control,
1286
	.interface_clear = ines_interface_clear,
1287
	.remote_enable = ines_remote_enable,
1288
	.enable_eos = ines_enable_eos,
1289
	.disable_eos = ines_disable_eos,
1290
	.parallel_poll = ines_parallel_poll,
1291
	.parallel_poll_configure = ines_parallel_poll_configure,
1292
	.parallel_poll_response = ines_parallel_poll_response,
1293
	.local_parallel_poll_mode = NULL, // XXX
1294
	.line_status = ines_line_status,
1295
	.update_status = ines_update_status,
1296
	.primary_address = ines_primary_address,
1297
	.secondary_address = ines_secondary_address,
1298
	.serial_poll_response = ines_serial_poll_response,
1299
	.serial_poll_status = ines_serial_poll_status,
1300
	.t1_delay = ines_t1_delay,
1301
	.return_to_local = ines_return_to_local,
1302
};
1303

1304
static irqreturn_t ines_pcmcia_interrupt(int irq, void *arg)
1305
{
1306
	struct gpib_board *board = arg;
1307

1308
	return ines_interrupt(board);
1309
}
1310

1311
static int ines_common_pcmcia_attach(struct gpib_board *board)
1312
{
1313
	struct ines_priv *ines_priv;
1314
	struct nec7210_priv *nec_priv;
1315
	int retval;
1316

1317
	if (!curr_dev) {
1318
		dev_err(board->gpib_dev, "no ines pcmcia cards found\n");
1319
		return -1;
1320
	}
1321

1322
	retval = ines_generic_attach(board);
1323
	if (retval)
1324
		return retval;
1325

1326
	ines_priv = board->private_data;
1327
	nec_priv = &ines_priv->nec7210_priv;
1328

1329
	if (!request_region(curr_dev->resource[0]->start,
1330
			    resource_size(curr_dev->resource[0]), DRV_NAME)) {
1331
		dev_err(board->gpib_dev, "ioports at 0x%lx already in use\n",
1332
			(unsigned long)(curr_dev->resource[0]->start));
1333
		return -1;
1334
	}
1335

1336
	nec_priv->iobase = curr_dev->resource[0]->start;
1337

1338
	nec7210_board_reset(nec_priv, board);
1339

1340
	if (request_irq(curr_dev->irq, ines_pcmcia_interrupt, IRQF_SHARED,
1341
			"pcmcia-gpib", board))	{
1342
		dev_err(board->gpib_dev, "can't request IRQ %d\n", curr_dev->irq);
1343
		return -1;
1344
	}
1345
	ines_priv->irq = curr_dev->irq;
1346

1347
	return 0;
1348
}
1349

1350
static int ines_pcmcia_attach(struct gpib_board *board, const struct gpib_board_config *config)
1351
{
1352
	struct ines_priv *ines_priv;
1353
	int retval;
1354

1355
	retval = ines_common_pcmcia_attach(board);
1356
	if (retval < 0)
1357
		return retval;
1358

1359
	ines_priv = board->private_data;
1360
	ines_online(ines_priv, board, 0);
1361

1362
	return 0;
1363
}
1364

1365
static int ines_pcmcia_accel_attach(struct gpib_board *board,
1366
				    const struct gpib_board_config *config)
1367
{
1368
	struct ines_priv *ines_priv;
1369
	int retval;
1370

1371
	retval = ines_common_pcmcia_attach(board);
1372
	if (retval < 0)
1373
		return retval;
1374

1375
	ines_priv = board->private_data;
1376
	ines_online(ines_priv, board, 1);
1377

1378
	return 0;
1379
}
1380

1381
static void ines_pcmcia_detach(struct gpib_board *board)
1382
{
1383
	struct ines_priv *ines_priv = board->private_data;
1384
	struct nec7210_priv *nec_priv;
1385

1386
	if (ines_priv) {
1387
		nec_priv = &ines_priv->nec7210_priv;
1388
		if (ines_priv->irq)
1389
			free_irq(ines_priv->irq, board);
1390
		if (nec_priv->iobase) {
1391
			nec7210_board_reset(nec_priv, board);
1392
			release_region(nec_priv->iobase, ines_pcmcia_iosize);
1393
		}
1394
	}
1395
	ines_free_private(board);
1396
}
1397

1398
#endif /* CONFIG_GPIB_PCMCIA */
1399

1400
static int __init ines_init_module(void)
1401
{
1402
	int ret;
1403

1404
	ret = pci_register_driver(&ines_pci_driver);
1405
	if (ret) {
1406
		pr_err("pci_register_driver failed: error = %d\n", ret);
1407
		return ret;
1408
	}
1409

1410
	ret = gpib_register_driver(&ines_pci_interface, THIS_MODULE);
1411
	if (ret) {
1412
		pr_err("gpib_register_driver failed: error = %d\n", ret);
1413
		goto err_pci;
1414
	}
1415

1416
	ret = gpib_register_driver(&ines_pci_unaccel_interface, THIS_MODULE);
1417
	if (ret) {
1418
		pr_err("gpib_register_driver failed: error = %d\n", ret);
1419
		goto err_pci_unaccel;
1420
	}
1421

1422
	ret = gpib_register_driver(&ines_pci_accel_interface, THIS_MODULE);
1423
	if (ret) {
1424
		pr_err("gpib_register_driver failed: error = %d\n", ret);
1425
		goto err_pci_accel;
1426
	}
1427

1428
	ret = gpib_register_driver(&ines_isa_interface, THIS_MODULE);
1429
	if (ret) {
1430
		pr_err("gpib_register_driver failed: error = %d\n", ret);
1431
		goto err_isa;
1432
	}
1433

1434
#ifdef CONFIG_GPIB_PCMCIA
1435
	ret = gpib_register_driver(&ines_pcmcia_interface, THIS_MODULE);
1436
	if (ret) {
1437
		pr_err("gpib_register_driver failed: error = %d\n", ret);
1438
		goto err_pcmcia;
1439
	}
1440

1441
	ret = gpib_register_driver(&ines_pcmcia_unaccel_interface, THIS_MODULE);
1442
	if (ret) {
1443
		pr_err("gpib_register_driver failed: error = %d\n", ret);
1444
		goto err_pcmcia_unaccel;
1445
	}
1446

1447
	ret = gpib_register_driver(&ines_pcmcia_accel_interface, THIS_MODULE);
1448
	if (ret) {
1449
		pr_err("gpib_register_driver failed: error = %d\n", ret);
1450
		goto err_pcmcia_accel;
1451
	}
1452

1453
	ret = pcmcia_register_driver(&ines_gpib_cs_driver);
1454
	if (ret) {
1455
		pr_err("pcmcia_register_driver failed: error = %d\n", ret);
1456
		goto err_pcmcia_driver;
1457
	}
1458
#endif
1459

1460
	return 0;
1461

1462
#ifdef CONFIG_GPIB_PCMCIA
1463
err_pcmcia_driver:
1464
	gpib_unregister_driver(&ines_pcmcia_accel_interface);
1465
err_pcmcia_accel:
1466
	gpib_unregister_driver(&ines_pcmcia_unaccel_interface);
1467
err_pcmcia_unaccel:
1468
	gpib_unregister_driver(&ines_pcmcia_interface);
1469
err_pcmcia:
1470
#endif
1471
	gpib_unregister_driver(&ines_isa_interface);
1472
err_isa:
1473
	gpib_unregister_driver(&ines_pci_accel_interface);
1474
err_pci_accel:
1475
	gpib_unregister_driver(&ines_pci_unaccel_interface);
1476
err_pci_unaccel:
1477
	gpib_unregister_driver(&ines_pci_interface);
1478
err_pci:
1479
	pci_unregister_driver(&ines_pci_driver);
1480

1481
	return ret;
1482
}
1483

1484
static void __exit ines_exit_module(void)
1485
{
1486
	gpib_unregister_driver(&ines_pci_interface);
1487
	gpib_unregister_driver(&ines_pci_unaccel_interface);
1488
	gpib_unregister_driver(&ines_pci_accel_interface);
1489
	gpib_unregister_driver(&ines_isa_interface);
1490
#ifdef CONFIG_GPIB_PCMCIA
1491
	gpib_unregister_driver(&ines_pcmcia_interface);
1492
	gpib_unregister_driver(&ines_pcmcia_unaccel_interface);
1493
	gpib_unregister_driver(&ines_pcmcia_accel_interface);
1494
	ines_pcmcia_cleanup_module();
1495
#endif
1496

1497
	pci_unregister_driver(&ines_pci_driver);
1498
}
1499

1500
module_init(ines_init_module);
1501
module_exit(ines_exit_module);
1502

1503