1// SPDX-License-Identifier: GPL-2.0
2
3/***************************************************************************
4 * copyright : (C) 1999 Axel Dziemba (axel.dziemba@ines.de)
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
25MODULE_LICENSE("GPL");
26MODULE_DESCRIPTION("GPIB driver for Ines iGPIB 72010");
27
28static irqreturn_t ines_interrupt(struct gpib_board *board);
29
30static 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(priv: ines_priv, register_number: 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
60static 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, value: (count >> 8) & 0xff, register_number: XFER_COUNT_UPPER);
67 ines_outb(priv, value: count & 0xff, register_number: XFER_COUNT_LOWER);
68}
69
70static 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, priv: nec_priv, nano_sec);
77
78 if (nano_sec <= 250) {
79 write_byte(priv: nec_priv, byte: INES_AUXD | INES_FOLLOWING_T1_250ns |
80 INES_INITIAL_T1_2000ns, register_number: AUXMR);
81 retval = 250;
82 } else if (nano_sec <= 350) {
83 write_byte(priv: nec_priv, byte: INES_AUXD | INES_FOLLOWING_T1_350ns |
84 INES_INITIAL_T1_2000ns, register_number: AUXMR);
85 retval = 350;
86 } else {
87 write_byte(priv: nec_priv, byte: INES_AUXD | INES_FOLLOWING_T1_500ns |
88 INES_INITIAL_T1_2000ns, register_number: AUXMR);
89 retval = 500;
90 }
91
92 return retval;
93}
94
95static inline unsigned short num_in_fifo_bytes(struct ines_priv *ines_priv)
96{
97 return ines_inb(priv: ines_priv, register_number: IN_FIFO_COUNT);
98}
99
100static 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(priv: nec_priv, register_number: 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
138static 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(nr: DEV_CLEAR_BN, addr: &nec_priv->state);
152
153 write_byte(priv: nec_priv, byte: INES_RFD_HLD_IMMEDIATE, register_number: AUXMR);
154
155 // clear in fifo
156 nec7210_set_reg_bits(priv: nec_priv, reg: ADMR, mask: IN_FIFO_ENABLE_BIT, bits: 0);
157 nec7210_set_reg_bits(priv: nec_priv, reg: ADMR, mask: IN_FIFO_ENABLE_BIT, bits: 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(priv: ines_priv, value: ines_priv->extend_mode_bits, register_number: EXTEND_MODE);
162
163 counter_setting = length - num_in_fifo_bytes(ines_priv);
164 if (counter_setting > 0) {
165 ines_set_xfer_counter(priv: ines_priv, count: length);
166 ines_priv->extend_mode_bits |= XFER_COUNTER_ENABLE_BIT;
167 ines_outb(priv: ines_priv, value: ines_priv->extend_mode_bits, register_number: EXTEND_MODE);
168
169 // holdoff on END
170 nec7210_set_handshake_mode(board, priv: nec_priv, mode: HR_HLDE);
171 /* release rfd holdoff */
172 write_byte(priv: nec_priv, byte: AUX_FH, register_number: AUXMR);
173 }
174
175 retval = pio_read(board, ines_priv, buffer, length, nbytes: bytes_read);
176 ines_priv->extend_mode_bits &= ~XFER_COUNTER_ENABLE_BIT;
177 ines_outb(priv: ines_priv, value: ines_priv->extend_mode_bits, register_number: EXTEND_MODE);
178 if (retval < 0) {
179 write_byte(priv: nec_priv, byte: INES_RFD_HLD_IMMEDIATE, register_number: AUXMR);
180 return retval;
181 }
182 if (test_and_clear_bit(nr: RECEIVED_END_BN, addr: &nec_priv->state))
183 *end = 1;
184
185 return retval;
186}
187
188static const int out_fifo_size = 0xff;
189
190static inline unsigned short num_out_fifo_bytes(struct ines_priv *ines_priv)
191{
192 return ines_inb(priv: ines_priv, register_number: OUT_FIFO_COUNT);
193}
194
195static 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
218static 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(priv: nec_priv, reg: ADMR, mask: OUT_FIFO_ENABLE_BIT, bits: 0);
230 nec7210_set_reg_bits(priv: nec_priv, reg: ADMR, mask: OUT_FIFO_ENABLE_BIT, bits: 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(priv: ines_priv, value: ines_priv->extend_mode_bits, register_number: EXTEND_MODE);
236
237 ines_set_xfer_counter(priv: ines_priv, count: 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(priv: ines_priv, value: ines_priv->extend_mode_bits, register_number: EXTEND_MODE);
242
243 while (count < length) {
244 retval = ines_write_wait(board, ines_priv, fifo_threshold: 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(priv: nec_priv, byte: buffer[count++], register_number: CDOR);
253 }
254 if (retval < 0) {
255 ines_priv->extend_mode_bits &= ~XFER_COUNTER_ENABLE_BIT;
256 ines_outb(priv: ines_priv, value: ines_priv->extend_mode_bits, register_number: 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, fifo_threshold: 1);
262 ines_priv->extend_mode_bits &= ~XFER_COUNTER_ENABLE_BIT;
263 ines_outb(priv: ines_priv, value: ines_priv->extend_mode_bits, register_number: EXTEND_MODE);
264 *bytes_written = length - num_out_fifo_bytes(ines_priv);
265
266 return retval;
267}
268
269static 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(port: nec_priv->iobase +
277 QUANCOM_IRQ_CONTROL_STATUS_REG) &
278 QUANCOM_IRQ_ASSERTED_BIT))
279 outb(value: QUANCOM_IRQ_ENABLE_BIT, port: nec_priv->iobase +
280 QUANCOM_IRQ_CONTROL_STATUS_REG);
281 }
282
283 return ines_interrupt(board);
284}
285
286static 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, priv: nec_priv);
297 isr3_bits = ines_inb(priv, register_number: ISR3);
298 isr4_bits = ines_inb(priv, register_number: ISR4);
299 if (isr3_bits & IFC_ACTIVE_BIT) {
300 push_gpib_event(board, event_type: 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(lock: &board->spinlock, flags);
315 return IRQ_HANDLED;
316}
317
318static int ines_pci_attach(struct gpib_board *board, const struct gpib_board_config *config);
319static int ines_pci_accel_attach(struct gpib_board *board, const struct gpib_board_config *config);
320static int ines_isa_attach(struct gpib_board *board, const struct gpib_board_config *config);
321
322static void ines_pci_detach(struct gpib_board *board);
323static void ines_isa_detach(struct gpib_board *board);
324
325enum ines_pci_vendor_ids {
326 PCI_VENDOR_ID_INES_QUICKLOGIC = 0x16da
327};
328
329enum ines_pci_device_ids {
330 PCI_DEVICE_ID_INES_GPIB_AMCC = 0x8507,
331 PCI_DEVICE_ID_INES_GPIB_QL5030 = 0x11,
332};
333
334enum ines_pci_subdevice_ids {
335 PCI_SUBDEVICE_ID_INES_GPIB = 0x1072
336};
337
338static 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};
348MODULE_DEVICE_TABLE(pci, ines_pci_table);
349
350struct 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
360static 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
395static const int num_pci_chips = ARRAY_SIZE(pci_ids);
396
397// wrappers for interface functions
398static 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: &priv->nec7210_priv, buffer, length, end, bytes_read);
407 if (retval < 0) {
408 write_byte(priv: nec_priv, byte: INES_RFD_HLD_IMMEDIATE, register_number: AUXMR);
409
410 set_bit(nr: RFD_HOLDOFF_BN, addr: &nec_priv->state);
411
412 nec7210_read_data_in(board, priv: nec_priv, end: &dummy);
413 }
414 return retval;
415}
416
417static 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: &priv->nec7210_priv, buffer, length, send_eoi, bytes_written);
423}
424
425static 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: &priv->nec7210_priv, buffer, length, bytes_written);
430}
431
432static 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: &priv->nec7210_priv, syncronous: synchronous);
437}
438
439static 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: &priv->nec7210_priv);
444}
445
446static 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: &priv->nec7210_priv, request_control);
451}
452
453static 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: &priv->nec7210_priv, assert);
458}
459
460static 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: &priv->nec7210_priv, enable);
465}
466
467static 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: &priv->nec7210_priv, eos_bytes: eos_byte, compare_8_bits);
472}
473
474static void ines_disable_eos(struct gpib_board *board)
475{
476 struct ines_priv *priv = board->private_data;
477
478 nec7210_disable_eos(board, priv: &priv->nec7210_priv);
479}
480
481static 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: &priv->nec7210_priv, clear_mask);
486}
487
488static 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: &priv->nec7210_priv, address);
493}
494
495static 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: &priv->nec7210_priv, address, enable);
500}
501
502static 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: &priv->nec7210_priv, result);
507}
508
509static 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: &priv->nec7210_priv, configuration: config);
514}
515
516static 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: &priv->nec7210_priv, ist);
521}
522
523static 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: &priv->nec7210_priv, status);
528}
529
530static 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: &priv->nec7210_priv);
535}
536
537static 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: &priv->nec7210_priv);
542}
543
544static 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
572static 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
600static 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
628static 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
656static int ines_allocate_private(struct gpib_board *board)
657{
658 struct ines_priv *priv;
659
660 board->private_data = kmalloc(sizeof(struct ines_priv), GFP_KERNEL);
661 if (!board->private_data)
662 return -1;
663 priv = board->private_data;
664 memset(priv, 0, sizeof(struct ines_priv));
665 init_nec7210_private(priv: &priv->nec7210_priv);
666 return 0;
667}
668
669static void ines_free_private(struct gpib_board *board)
670{
671 kfree(objp: board->private_data);
672 board->private_data = NULL;
673}
674
675static int ines_generic_attach(struct gpib_board *board)
676{
677 struct ines_priv *ines_priv;
678 struct nec7210_priv *nec_priv;
679
680 board->status = 0;
681
682 if (ines_allocate_private(board))
683 return -ENOMEM;
684 ines_priv = board->private_data;
685 nec_priv = &ines_priv->nec7210_priv;
686 nec_priv->read_byte = nec7210_ioport_read_byte;
687 nec_priv->write_byte = nec7210_ioport_write_byte;
688 nec_priv->offset = 1;
689 nec_priv->type = IGPIB7210;
690 ines_priv->pci_chip_type = PCI_CHIP_NONE;
691
692 return 0;
693}
694
695static void ines_online(struct ines_priv *ines_priv, const struct gpib_board *board, int use_accel)
696{
697 struct nec7210_priv *nec_priv = &ines_priv->nec7210_priv;
698
699 /* ines doesn't seem to use internal count register */
700 write_byte(priv: nec_priv, byte: ICR | 0, register_number: AUXMR);
701
702 write_byte(priv: nec_priv, byte: INES_AUX_XMODE, register_number: AUXMR);
703 write_byte(priv: nec_priv, byte: INES_RFD_HLD_IMMEDIATE, register_number: AUXMR);
704
705 set_bit(nr: RFD_HOLDOFF_BN, addr: &nec_priv->state);
706
707 write_byte(priv: nec_priv, byte: INES_AUXD | 0, register_number: AUXMR);
708 ines_outb(priv: ines_priv, value: 0, register_number: XDMA_CONTROL);
709 ines_priv->extend_mode_bits = 0;
710 ines_outb(priv: ines_priv, value: ines_priv->extend_mode_bits, register_number: EXTEND_MODE);
711 if (use_accel) {
712 ines_outb(priv: ines_priv, value: 0x80, register_number: OUT_FIFO_WATERMARK);
713 ines_outb(priv: ines_priv, value: 0x80, register_number: IN_FIFO_WATERMARK);
714 ines_outb(priv: ines_priv, value: IFC_ACTIVE_BIT | ATN_ACTIVE_BIT |
715 FIFO_ERROR_BIT | XFER_COUNT_BIT, register_number: IMR3);
716 ines_outb(priv: ines_priv, value: IN_FIFO_WATERMARK_BIT | IN_FIFO_FULL_BIT |
717 OUT_FIFO_WATERMARK_BIT | OUT_FIFO_EMPTY_BIT, register_number: IMR4);
718 } else {
719 nec7210_set_reg_bits(priv: nec_priv, reg: ADMR, mask: IN_FIFO_ENABLE_BIT | OUT_FIFO_ENABLE_BIT, bits: 0);
720 ines_outb(priv: ines_priv, value: IFC_ACTIVE_BIT | FIFO_ERROR_BIT, register_number: IMR3);
721 ines_outb(priv: ines_priv, value: 0, register_number: IMR4);
722 }
723
724 nec7210_board_online(priv: nec_priv, board);
725 if (use_accel)
726 nec7210_set_reg_bits(priv: nec_priv, reg: IMR1, mask: HR_DOIE | HR_DIIE, bits: 0);
727}
728
729static int ines_common_pci_attach(struct gpib_board *board, const struct gpib_board_config *config)
730{
731 struct ines_priv *ines_priv;
732 struct nec7210_priv *nec_priv;
733 int isr_flags = 0;
734 int retval;
735 struct ines_pci_id found_id;
736 unsigned int i;
737 struct pci_dev *pdev;
738
739 memset(&found_id, 0, sizeof(found_id));
740
741 retval = ines_generic_attach(board);
742 if (retval)
743 return retval;
744
745 ines_priv = board->private_data;
746 nec_priv = &ines_priv->nec7210_priv;
747
748 // find board
749 ines_priv->pci_device = NULL;
750 for (i = 0; i < num_pci_chips && !ines_priv->pci_device; i++) {
751 pdev = NULL;
752 do {
753 if (pci_ids[i].subsystem_vendor_id >= 0 &&
754 pci_ids[i].subsystem_device_id >= 0)
755 pdev = pci_get_subsys(vendor: pci_ids[i].vendor_id, device: pci_ids[i].device_id,
756 ss_vendor: pci_ids[i].subsystem_vendor_id,
757 ss_device: pci_ids[i].subsystem_device_id, from: pdev);
758 else
759 pdev = pci_get_device(vendor: pci_ids[i].vendor_id, device: pci_ids[i].device_id,
760 from: pdev);
761 if (!pdev)
762 break;
763 if (config->pci_bus >= 0 && config->pci_bus != pdev->bus->number)
764 continue;
765 if (config->pci_slot >= 0 && config->pci_slot != PCI_SLOT(pdev->devfn))
766 continue;
767 found_id = pci_ids[i];
768 ines_priv->pci_device = pdev;
769 break;
770 } while (1);
771 }
772 if (!ines_priv->pci_device) {
773 dev_err(board->gpib_dev, "could not find ines PCI board\n");
774 return -1;
775 }
776
777 if (pci_enable_device(dev: ines_priv->pci_device)) {
778 dev_err(board->gpib_dev, "error enabling pci device\n");
779 return -1;
780 }
781
782 if (pci_request_regions(ines_priv->pci_device, DRV_NAME))
783 return -1;
784 nec_priv->iobase = pci_resource_start(ines_priv->pci_device,
785 found_id.gpib_region);
786
787 ines_priv->pci_chip_type = found_id.pci_chip_type;
788 nec_priv->offset = found_id.io_offset;
789 switch (ines_priv->pci_chip_type) {
790 case PCI_CHIP_PLX9050:
791 ines_priv->plx_iobase = pci_resource_start(ines_priv->pci_device, 1);
792 break;
793 case PCI_CHIP_AMCC5920:
794 ines_priv->amcc_iobase = pci_resource_start(ines_priv->pci_device, 0);
795 break;
796 case PCI_CHIP_QUANCOM:
797 break;
798 case PCI_CHIP_QUICKLOGIC5030:
799 break;
800 default:
801 dev_err(board->gpib_dev, "unspecified chip type? (bug)\n");
802 nec_priv->iobase = 0;
803 pci_release_regions(ines_priv->pci_device);
804 return -1;
805 }
806
807 nec7210_board_reset(priv: nec_priv, board);
808#ifdef QUANCOM_PCI
809 if (ines_priv->pci_chip_type == PCI_CHIP_QUANCOM) {
810 /* change interrupt polarity */
811 nec_priv->auxb_bits |= HR_INV;
812 ines_outb(ines_priv, nec_priv->auxb_bits, AUXMR);
813 }
814#endif
815 isr_flags |= IRQF_SHARED;
816 if (request_irq(irq: ines_priv->pci_device->irq, handler: ines_pci_interrupt, flags: isr_flags,
817 DRV_NAME, dev: board)) {
818 dev_err(board->gpib_dev, "can't request IRQ %d\n", ines_priv->pci_device->irq);
819 return -1;
820 }
821 ines_priv->irq = ines_priv->pci_device->irq;
822
823 // enable interrupts on pci chip
824 switch (ines_priv->pci_chip_type) {
825 case PCI_CHIP_PLX9050:
826 outl(value: PLX9050_LINTR1_EN_BIT | PLX9050_LINTR1_POLARITY_BIT | PLX9050_PCI_INTR_EN_BIT,
827 port: ines_priv->plx_iobase + PLX9050_INTCSR_REG);
828 break;
829 case PCI_CHIP_AMCC5920:
830 {
831 static const int region = 1;
832 static const int num_wait_states = 7;
833 u32 bits;
834
835 bits = amcc_prefetch_bits(region, prefetch: PREFETCH_DISABLED);
836 bits |= amcc_PTADR_mode_bit(region);
837 bits |= amcc_disable_write_fifo_bit(region);
838 bits |= amcc_wait_state_bits(region, num_wait_states);
839 outl(value: bits, port: ines_priv->amcc_iobase + AMCC_PASS_THRU_REG);
840 outl(value: AMCC_ADDON_INTR_ENABLE_BIT, port: ines_priv->amcc_iobase + AMCC_INTCS_REG);
841 }
842 break;
843 case PCI_CHIP_QUANCOM:
844 outb(value: QUANCOM_IRQ_ENABLE_BIT, port: nec_priv->iobase +
845 QUANCOM_IRQ_CONTROL_STATUS_REG);
846 break;
847 case PCI_CHIP_QUICKLOGIC5030:
848 break;
849 default:
850 dev_err(board->gpib_dev, "unspecified chip type? (bug)\n");
851 return -1;
852 }
853
854 return 0;
855}
856
857static int ines_pci_attach(struct gpib_board *board, const struct gpib_board_config *config)
858{
859 struct ines_priv *ines_priv;
860 int retval;
861
862 retval = ines_common_pci_attach(board, config);
863 if (retval < 0)
864 return retval;
865
866 ines_priv = board->private_data;
867 ines_online(ines_priv, board, use_accel: 0);
868
869 return 0;
870}
871
872static int ines_pci_accel_attach(struct gpib_board *board, const struct gpib_board_config *config)
873{
874 struct ines_priv *ines_priv;
875 int retval;
876
877 retval = ines_common_pci_attach(board, config);
878 if (retval < 0)
879 return retval;
880
881 ines_priv = board->private_data;
882 ines_online(ines_priv, board, use_accel: 1);
883
884 return 0;
885}
886
887static const int ines_isa_iosize = 0x20;
888
889static int ines_isa_attach(struct gpib_board *board, const struct gpib_board_config *config)
890{
891 struct ines_priv *ines_priv;
892 struct nec7210_priv *nec_priv;
893 int isr_flags = 0;
894 int retval;
895
896 retval = ines_generic_attach(board);
897 if (retval)
898 return retval;
899
900 ines_priv = board->private_data;
901 nec_priv = &ines_priv->nec7210_priv;
902
903 if (!request_region(config->ibbase, ines_isa_iosize, DRV_NAME)) {
904 dev_err(board->gpib_dev, "ioports at 0x%x already in use\n",
905 config->ibbase);
906 return -EBUSY;
907 }
908 nec_priv->iobase = config->ibbase;
909 nec_priv->offset = 1;
910 nec7210_board_reset(priv: nec_priv, board);
911 if (request_irq(irq: config->ibirq, handler: ines_pci_interrupt, flags: isr_flags, DRV_NAME, dev: board)) {
912 dev_err(board->gpib_dev, "failed to allocate IRQ %d\n", config->ibirq);
913 return -1;
914 }
915 ines_priv->irq = config->ibirq;
916 ines_online(ines_priv, board, use_accel: 1);
917 return 0;
918}
919
920static void ines_pci_detach(struct gpib_board *board)
921{
922 struct ines_priv *ines_priv = board->private_data;
923 struct nec7210_priv *nec_priv;
924
925 if (ines_priv) {
926 nec_priv = &ines_priv->nec7210_priv;
927 if (ines_priv->irq) {
928 // disable interrupts
929 switch (ines_priv->pci_chip_type) {
930 case PCI_CHIP_AMCC5920:
931 if (ines_priv->plx_iobase)
932 outl(value: 0, port: ines_priv->plx_iobase + PLX9050_INTCSR_REG);
933 break;
934 case PCI_CHIP_QUANCOM:
935 if (nec_priv->iobase)
936 outb(value: 0, port: nec_priv->iobase +
937 QUANCOM_IRQ_CONTROL_STATUS_REG);
938 break;
939 default:
940 break;
941 }
942 free_irq(ines_priv->irq, board);
943 }
944 if (nec_priv->iobase) {
945 nec7210_board_reset(priv: nec_priv, board);
946 pci_release_regions(ines_priv->pci_device);
947 }
948 if (ines_priv->pci_device)
949 pci_dev_put(dev: ines_priv->pci_device);
950 }
951 ines_free_private(board);
952}
953
954static void ines_isa_detach(struct gpib_board *board)
955{
956 struct ines_priv *ines_priv = board->private_data;
957 struct nec7210_priv *nec_priv;
958
959 if (ines_priv) {
960 nec_priv = &ines_priv->nec7210_priv;
961 if (ines_priv->irq)
962 free_irq(ines_priv->irq, board);
963 if (nec_priv->iobase) {
964 nec7210_board_reset(priv: nec_priv, board);
965 release_region(nec_priv->iobase, ines_isa_iosize);
966 }
967 }
968 ines_free_private(board);
969}
970
971static int ines_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
972{
973 return 0;
974}
975
976static struct pci_driver ines_pci_driver = {
977 .name = "ines_gpib",
978 .id_table = ines_pci_table,
979 .probe = &ines_pci_probe
980};
981
982#ifdef CONFIG_GPIB_PCMCIA
983
984#include <linux/kernel.h>
985#include <linux/ptrace.h>
986#include <linux/string.h>
987#include <linux/timer.h>
988
989#include <pcmcia/cistpl.h>
990#include <pcmcia/ds.h>
991#include <pcmcia/cisreg.h>
992
993static const int ines_pcmcia_iosize = 0x20;
994
995/*
996 * The event() function is this driver's Card Services event handler.
997 * It will be called by Card Services when an appropriate card status
998 * event is received. The config() and release() entry points are
999 * used to configure or release a socket, in response to card insertion
1000 * and ejection events. They are invoked from the gpib event
1001 * handler.
1002 */
1003
1004static int ines_gpib_config(struct pcmcia_device *link);
1005static void ines_gpib_release(struct pcmcia_device *link);
1006static int ines_pcmcia_attach(struct gpib_board *board, const struct gpib_board_config *config);
1007static int ines_pcmcia_accel_attach(struct gpib_board *board,
1008 const struct gpib_board_config *config);
1009static void ines_pcmcia_detach(struct gpib_board *board);
1010static int ines_common_pcmcia_attach(struct gpib_board *board);
1011/*
1012 * A linked list of "instances" of the gpib device. Each actual
1013 * PCMCIA card corresponds to one device instance, and is described
1014 * by one dev_link_t structure (defined in ds.h).
1015 *
1016 * You may not want to use a linked list for this -- for example, the
1017 * memory card driver uses an array of dev_link_t pointers, where minor
1018 * device numbers are used to derive the corresponding array index.
1019 */
1020
1021static struct pcmcia_device *curr_dev;
1022
1023/*
1024 * A dev_link_t structure has fields for most things that are needed
1025 * to keep track of a socket, but there will usually be some device
1026 * specific information that also needs to be kept track of. The
1027 * 'priv' pointer in a dev_link_t structure can be used to point to
1028 * a device-specific private data structure, like this.
1029 *
1030 * A driver needs to provide a dev_node_t structure for each device
1031 * on a card. In some cases, there is only one device per card (for
1032 * example, ethernet cards, modems). In other cases, there may be
1033 * many actual or logical devices (SCSI adapters, memory cards with
1034 * multiple partitions). The dev_node_t structures need to be kept
1035 * in a linked list starting at the 'dev' field of a dev_link_t
1036 * structure. We allocate them in the card's private data structure,
1037 * because they generally can't be allocated dynamically.
1038 */
1039
1040struct local_info {
1041 struct pcmcia_device *p_dev;
1042 struct gpib_board *dev;
1043 u_short manfid;
1044 u_short cardid;
1045};
1046
1047/*
1048 * gpib_attach() creates an "instance" of the driver, allocating
1049 * local data structures for one device. The device is registered
1050 * with Card Services.
1051 *
1052 * The dev_link structure is initialized, but we don't actually
1053 * configure the card at this point -- we wait until we receive a
1054 * card insertion event.
1055 */
1056static int ines_gpib_probe(struct pcmcia_device *link)
1057{
1058 struct local_info *info;
1059
1060// int ret, i;
1061
1062 /* Allocate space for private device-specific data */
1063 info = kzalloc(sizeof(*info), GFP_KERNEL);
1064 if (!info)
1065 return -ENOMEM;
1066
1067 info->p_dev = link;
1068 link->priv = info;
1069
1070 /* The io structure describes IO port mapping */
1071 link->resource[0]->end = 32;
1072 link->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
1073 link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
1074 link->io_lines = 5;
1075
1076 /* General socket configuration */
1077 link->config_flags = CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
1078
1079 /* Register with Card Services */
1080 curr_dev = link;
1081 return ines_gpib_config(link);
1082}
1083
1084/*
1085 * This deletes a driver "instance". The device is de-registered
1086 * with Card Services. If it has been released, all local data
1087 * structures are freed. Otherwise, the structures will be freed
1088 * when the device is released.
1089 */
1090static void ines_gpib_remove(struct pcmcia_device *link)
1091{
1092 struct local_info *info = link->priv;
1093 //struct struct gpib_board *dev = info->dev;
1094
1095 if (info->dev)
1096 ines_pcmcia_detach(board: info->dev);
1097 ines_gpib_release(link);
1098
1099 //free_netdev(dev);
1100 kfree(objp: info);
1101}
1102
1103static int ines_gpib_config_iteration(struct pcmcia_device *link, void *priv_data)
1104{
1105 return pcmcia_request_io(p_dev: link);
1106}
1107
1108/*
1109 * gpib_config() is scheduled to run after a CARD_INSERTION event
1110 * is received, to configure the PCMCIA socket, and to make the
1111 * device available to the system.
1112 */
1113static int ines_gpib_config(struct pcmcia_device *link)
1114{
1115 int retval;
1116 void __iomem *virt;
1117
1118 retval = pcmcia_loop_config(p_dev: link, conf_check: &ines_gpib_config_iteration, NULL);
1119 if (retval) {
1120 dev_warn(&link->dev, "no configuration found\n");
1121 ines_gpib_release(link);
1122 return -ENODEV;
1123 }
1124
1125 dev_dbg(&link->dev, "ines_cs: manufacturer: 0x%x card: 0x%x\n",
1126 link->manf_id, link->card_id);
1127
1128 /*
1129 * for the ines card we have to setup the configuration registers in
1130 * attribute memory here
1131 */
1132 link->resource[2]->flags |= WIN_MEMORY_TYPE_AM | WIN_DATA_WIDTH_8 | WIN_ENABLE;
1133 link->resource[2]->end = 0x1000;
1134 retval = pcmcia_request_window(p_dev: link, res: link->resource[2], speed: 250);
1135 if (retval) {
1136 dev_warn(&link->dev, "pcmcia_request_window failed\n");
1137 ines_gpib_release(link);
1138 return -ENODEV;
1139 }
1140 retval = pcmcia_map_mem_page(p_dev: link, res: link->resource[2], offset: 0);
1141 if (retval) {
1142 dev_warn(&link->dev, "pcmcia_map_mem_page failed\n");
1143 ines_gpib_release(link);
1144 return -ENODEV;
1145 }
1146 virt = ioremap(offset: link->resource[2]->start, size: resource_size(res: link->resource[2]));
1147 writeb(val: (link->resource[2]->start >> 2) & 0xff, addr: virt + 0xf0); // IOWindow base
1148 iounmap(addr: virt);
1149
1150 /*
1151 * This actually configures the PCMCIA socket -- setting up
1152 * the I/O windows and the interrupt mapping.
1153 */
1154 retval = pcmcia_enable_device(p_dev: link);
1155 if (retval) {
1156 ines_gpib_release(link);
1157 return -ENODEV;
1158 }
1159 return 0;
1160} /* gpib_config */
1161
1162/*
1163 * After a card is removed, gpib_release() will unregister the net
1164 * device, and release the PCMCIA configuration. If the device is
1165 * still open, this will be postponed until it is closed.
1166 */
1167
1168static void ines_gpib_release(struct pcmcia_device *link)
1169{
1170 pcmcia_disable_device(p_dev: link);
1171} /* gpib_release */
1172
1173static int ines_gpib_suspend(struct pcmcia_device *link)
1174{
1175 //struct local_info *info = link->priv;
1176 //struct struct gpib_board *dev = info->dev;
1177
1178 if (link->open)
1179 dev_err(&link->dev, "Device still open\n");
1180 //netif_device_detach(dev);
1181
1182 return 0;
1183}
1184
1185static int ines_gpib_resume(struct pcmcia_device *link)
1186{
1187 //struct local_info_t *info = link->priv;
1188 //struct struct gpib_board *dev = info->dev;
1189
1190 /*if (link->open) {
1191 * ni_gpib_probe(dev); / really?
1192 * //netif_device_attach(dev);
1193 *}
1194 */
1195 return ines_gpib_config(link);
1196}
1197
1198static struct pcmcia_device_id ines_pcmcia_ids[] = {
1199 PCMCIA_DEVICE_MANF_CARD(0x01b4, 0x4730),
1200 PCMCIA_DEVICE_NULL
1201};
1202MODULE_DEVICE_TABLE(pcmcia, ines_pcmcia_ids);
1203
1204static struct pcmcia_driver ines_gpib_cs_driver = {
1205 .owner = THIS_MODULE,
1206 .name = "ines_gpib_cs",
1207 .id_table = ines_pcmcia_ids,
1208 .probe = ines_gpib_probe,
1209 .remove = ines_gpib_remove,
1210 .suspend = ines_gpib_suspend,
1211 .resume = ines_gpib_resume,
1212};
1213
1214static void ines_pcmcia_cleanup_module(void)
1215{
1216 pcmcia_unregister_driver(driver: &ines_gpib_cs_driver);
1217}
1218
1219static struct gpib_interface ines_pcmcia_unaccel_interface = {
1220 .name = "ines_pcmcia_unaccel",
1221 .attach = ines_pcmcia_attach,
1222 .detach = ines_pcmcia_detach,
1223 .read = ines_read,
1224 .write = ines_write,
1225 .command = ines_command,
1226 .take_control = ines_take_control,
1227 .go_to_standby = ines_go_to_standby,
1228 .request_system_control = ines_request_system_control,
1229 .interface_clear = ines_interface_clear,
1230 .remote_enable = ines_remote_enable,
1231 .enable_eos = ines_enable_eos,
1232 .disable_eos = ines_disable_eos,
1233 .parallel_poll = ines_parallel_poll,
1234 .parallel_poll_configure = ines_parallel_poll_configure,
1235 .parallel_poll_response = ines_parallel_poll_response,
1236 .local_parallel_poll_mode = NULL, // XXX
1237 .line_status = ines_line_status,
1238 .update_status = ines_update_status,
1239 .primary_address = ines_primary_address,
1240 .secondary_address = ines_secondary_address,
1241 .serial_poll_response = ines_serial_poll_response,
1242 .serial_poll_status = ines_serial_poll_status,
1243 .t1_delay = ines_t1_delay,
1244 .return_to_local = ines_return_to_local,
1245};
1246
1247static struct gpib_interface ines_pcmcia_accel_interface = {
1248 .name = "ines_pcmcia_accel",
1249 .attach = ines_pcmcia_accel_attach,
1250 .detach = ines_pcmcia_detach,
1251 .read = ines_accel_read,
1252 .write = ines_accel_write,
1253 .command = ines_command,
1254 .take_control = ines_take_control,
1255 .go_to_standby = ines_go_to_standby,
1256 .request_system_control = ines_request_system_control,
1257 .interface_clear = ines_interface_clear,
1258 .remote_enable = ines_remote_enable,
1259 .enable_eos = ines_enable_eos,
1260 .disable_eos = ines_disable_eos,
1261 .parallel_poll = ines_parallel_poll,
1262 .parallel_poll_configure = ines_parallel_poll_configure,
1263 .parallel_poll_response = ines_parallel_poll_response,
1264 .local_parallel_poll_mode = NULL, // XXX
1265 .line_status = ines_line_status,
1266 .update_status = ines_update_status,
1267 .primary_address = ines_primary_address,
1268 .secondary_address = ines_secondary_address,
1269 .serial_poll_response = ines_serial_poll_response,
1270 .serial_poll_status = ines_serial_poll_status,
1271 .t1_delay = ines_t1_delay,
1272 .return_to_local = ines_return_to_local,
1273};
1274
1275static struct gpib_interface ines_pcmcia_interface = {
1276 .name = "ines_pcmcia",
1277 .attach = ines_pcmcia_accel_attach,
1278 .detach = ines_pcmcia_detach,
1279 .read = ines_accel_read,
1280 .write = ines_accel_write,
1281 .command = ines_command,
1282 .take_control = ines_take_control,
1283 .go_to_standby = ines_go_to_standby,
1284 .request_system_control = ines_request_system_control,
1285 .interface_clear = ines_interface_clear,
1286 .remote_enable = ines_remote_enable,
1287 .enable_eos = ines_enable_eos,
1288 .disable_eos = ines_disable_eos,
1289 .parallel_poll = ines_parallel_poll,
1290 .parallel_poll_configure = ines_parallel_poll_configure,
1291 .parallel_poll_response = ines_parallel_poll_response,
1292 .local_parallel_poll_mode = NULL, // XXX
1293 .line_status = ines_line_status,
1294 .update_status = ines_update_status,
1295 .primary_address = ines_primary_address,
1296 .secondary_address = ines_secondary_address,
1297 .serial_poll_response = ines_serial_poll_response,
1298 .serial_poll_status = ines_serial_poll_status,
1299 .t1_delay = ines_t1_delay,
1300 .return_to_local = ines_return_to_local,
1301};
1302
1303static irqreturn_t ines_pcmcia_interrupt(int irq, void *arg)
1304{
1305 struct gpib_board *board = arg;
1306
1307 return ines_interrupt(board);
1308}
1309
1310static int ines_common_pcmcia_attach(struct gpib_board *board)
1311{
1312 struct ines_priv *ines_priv;
1313 struct nec7210_priv *nec_priv;
1314 int retval;
1315
1316 if (!curr_dev) {
1317 dev_err(board->gpib_dev, "no ines pcmcia cards found\n");
1318 return -1;
1319 }
1320
1321 retval = ines_generic_attach(board);
1322 if (retval)
1323 return retval;
1324
1325 ines_priv = board->private_data;
1326 nec_priv = &ines_priv->nec7210_priv;
1327
1328 if (!request_region(curr_dev->resource[0]->start,
1329 resource_size(curr_dev->resource[0]), DRV_NAME)) {
1330 dev_err(board->gpib_dev, "ioports at 0x%lx already in use\n",
1331 (unsigned long)(curr_dev->resource[0]->start));
1332 return -1;
1333 }
1334
1335 nec_priv->iobase = curr_dev->resource[0]->start;
1336
1337 nec7210_board_reset(priv: nec_priv, board);
1338
1339 if (request_irq(irq: curr_dev->irq, handler: ines_pcmcia_interrupt, IRQF_SHARED,
1340 name: "pcmcia-gpib", dev: board)) {
1341 dev_err(board->gpib_dev, "can't request IRQ %d\n", curr_dev->irq);
1342 return -1;
1343 }
1344 ines_priv->irq = curr_dev->irq;
1345
1346 return 0;
1347}
1348
1349static int ines_pcmcia_attach(struct gpib_board *board, const struct gpib_board_config *config)
1350{
1351 struct ines_priv *ines_priv;
1352 int retval;
1353
1354 retval = ines_common_pcmcia_attach(board);
1355 if (retval < 0)
1356 return retval;
1357
1358 ines_priv = board->private_data;
1359 ines_online(ines_priv, board, use_accel: 0);
1360
1361 return 0;
1362}
1363
1364static int ines_pcmcia_accel_attach(struct gpib_board *board,
1365 const struct gpib_board_config *config)
1366{
1367 struct ines_priv *ines_priv;
1368 int retval;
1369
1370 retval = ines_common_pcmcia_attach(board);
1371 if (retval < 0)
1372 return retval;
1373
1374 ines_priv = board->private_data;
1375 ines_online(ines_priv, board, use_accel: 1);
1376
1377 return 0;
1378}
1379
1380static void ines_pcmcia_detach(struct gpib_board *board)
1381{
1382 struct ines_priv *ines_priv = board->private_data;
1383 struct nec7210_priv *nec_priv;
1384
1385 if (ines_priv) {
1386 nec_priv = &ines_priv->nec7210_priv;
1387 if (ines_priv->irq)
1388 free_irq(ines_priv->irq, board);
1389 if (nec_priv->iobase) {
1390 nec7210_board_reset(priv: nec_priv, board);
1391 release_region(nec_priv->iobase, ines_pcmcia_iosize);
1392 }
1393 }
1394 ines_free_private(board);
1395}
1396
1397#endif /* CONFIG_GPIB_PCMCIA */
1398
1399static int __init ines_init_module(void)
1400{
1401 int ret;
1402
1403 ret = pci_register_driver(&ines_pci_driver);
1404 if (ret) {
1405 pr_err("pci_register_driver failed: error = %d\n", ret);
1406 return ret;
1407 }
1408
1409 ret = gpib_register_driver(interface: &ines_pci_interface, THIS_MODULE);
1410 if (ret) {
1411 pr_err("gpib_register_driver failed: error = %d\n", ret);
1412 goto err_pci;
1413 }
1414
1415 ret = gpib_register_driver(interface: &ines_pci_unaccel_interface, THIS_MODULE);
1416 if (ret) {
1417 pr_err("gpib_register_driver failed: error = %d\n", ret);
1418 goto err_pci_unaccel;
1419 }
1420
1421 ret = gpib_register_driver(interface: &ines_pci_accel_interface, THIS_MODULE);
1422 if (ret) {
1423 pr_err("gpib_register_driver failed: error = %d\n", ret);
1424 goto err_pci_accel;
1425 }
1426
1427 ret = gpib_register_driver(interface: &ines_isa_interface, THIS_MODULE);
1428 if (ret) {
1429 pr_err("gpib_register_driver failed: error = %d\n", ret);
1430 goto err_isa;
1431 }
1432
1433#ifdef CONFIG_GPIB_PCMCIA
1434 ret = gpib_register_driver(interface: &ines_pcmcia_interface, THIS_MODULE);
1435 if (ret) {
1436 pr_err("gpib_register_driver failed: error = %d\n", ret);
1437 goto err_pcmcia;
1438 }
1439
1440 ret = gpib_register_driver(interface: &ines_pcmcia_unaccel_interface, THIS_MODULE);
1441 if (ret) {
1442 pr_err("gpib_register_driver failed: error = %d\n", ret);
1443 goto err_pcmcia_unaccel;
1444 }
1445
1446 ret = gpib_register_driver(interface: &ines_pcmcia_accel_interface, THIS_MODULE);
1447 if (ret) {
1448 pr_err("gpib_register_driver failed: error = %d\n", ret);
1449 goto err_pcmcia_accel;
1450 }
1451
1452 ret = pcmcia_register_driver(driver: &ines_gpib_cs_driver);
1453 if (ret) {
1454 pr_err("pcmcia_register_driver failed: error = %d\n", ret);
1455 goto err_pcmcia_driver;
1456 }
1457#endif
1458
1459 return 0;
1460
1461#ifdef CONFIG_GPIB_PCMCIA
1462err_pcmcia_driver:
1463 gpib_unregister_driver(interface: &ines_pcmcia_accel_interface);
1464err_pcmcia_accel:
1465 gpib_unregister_driver(interface: &ines_pcmcia_unaccel_interface);
1466err_pcmcia_unaccel:
1467 gpib_unregister_driver(interface: &ines_pcmcia_interface);
1468err_pcmcia:
1469#endif
1470 gpib_unregister_driver(interface: &ines_isa_interface);
1471err_isa:
1472 gpib_unregister_driver(interface: &ines_pci_accel_interface);
1473err_pci_accel:
1474 gpib_unregister_driver(interface: &ines_pci_unaccel_interface);
1475err_pci_unaccel:
1476 gpib_unregister_driver(interface: &ines_pci_interface);
1477err_pci:
1478 pci_unregister_driver(dev: &ines_pci_driver);
1479
1480 return ret;
1481}
1482
1483static void __exit ines_exit_module(void)
1484{
1485 gpib_unregister_driver(interface: &ines_pci_interface);
1486 gpib_unregister_driver(interface: &ines_pci_unaccel_interface);
1487 gpib_unregister_driver(interface: &ines_pci_accel_interface);
1488 gpib_unregister_driver(interface: &ines_isa_interface);
1489#ifdef CONFIG_GPIB_PCMCIA
1490 gpib_unregister_driver(interface: &ines_pcmcia_interface);
1491 gpib_unregister_driver(interface: &ines_pcmcia_unaccel_interface);
1492 gpib_unregister_driver(interface: &ines_pcmcia_accel_interface);
1493 ines_pcmcia_cleanup_module();
1494#endif
1495
1496 pci_unregister_driver(dev: &ines_pci_driver);
1497}
1498
1499module_init(ines_init_module);
1500module_exit(ines_exit_module);
1501

source code of linux/drivers/gpib/ines/ines_gpib.c