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 #include "ines.h"
9
10 #include <linux/pci.h>
11 #include <linux/pci_ids.h>
12 #include <linux/bitops.h>
13 #include <asm/dma.h>
14 #include <linux/io.h>
15 #include <linux/module.h>
16 #include <linux/init.h>
17 #include <linux/sched.h>
18 #include <linux/slab.h>
19 #include "gpib_pci_ids.h"
20
21 MODULE_LICENSE("GPL");
22 MODULE_DESCRIPTION("GPIB driver for Ines iGPIB 72010");
23
ines_line_status(const gpib_board_t * board)24 int ines_line_status(const gpib_board_t *board)
25 {
26 int status = ValidALL;
27 int bcm_bits;
28 struct ines_priv *ines_priv;
29 struct nec7210_priv *nec_priv;
30
31 ines_priv = board->private_data;
32 nec_priv = &ines_priv->nec7210_priv;
33
34 bcm_bits = ines_inb(ines_priv, BUS_CONTROL_MONITOR);
35
36 if (bcm_bits & BCM_REN_BIT)
37 status |= BusREN;
38 if (bcm_bits & BCM_IFC_BIT)
39 status |= BusIFC;
40 if (bcm_bits & BCM_SRQ_BIT)
41 status |= BusSRQ;
42 if (bcm_bits & BCM_EOI_BIT)
43 status |= BusEOI;
44 if (bcm_bits & BCM_NRFD_BIT)
45 status |= BusNRFD;
46 if (bcm_bits & BCM_NDAC_BIT)
47 status |= BusNDAC;
48 if (bcm_bits & BCM_DAV_BIT)
49 status |= BusDAV;
50 if (bcm_bits & BCM_ATN_BIT)
51 status |= BusATN;
52
53 return status;
54 }
55
ines_set_xfer_counter(struct ines_priv * priv,unsigned int count)56 void ines_set_xfer_counter(struct ines_priv *priv, unsigned int count)
57 {
58 if (count > 0xffff) {
59 pr_err("ines: bug! tried to set xfer counter > 0xffff\n");
60 return;
61 }
62 ines_outb(priv, (count >> 8) & 0xff, XFER_COUNT_UPPER);
63 ines_outb(priv, count & 0xff, XFER_COUNT_LOWER);
64 }
65
ines_t1_delay(gpib_board_t * board,unsigned int nano_sec)66 unsigned int ines_t1_delay(gpib_board_t *board, unsigned int nano_sec)
67 {
68 struct ines_priv *ines_priv = board->private_data;
69 struct nec7210_priv *nec_priv = &ines_priv->nec7210_priv;
70 unsigned int retval;
71
72 retval = nec7210_t1_delay(board, nec_priv, nano_sec);
73
74 if (nano_sec <= 250) {
75 write_byte(nec_priv, INES_AUXD | INES_FOLLOWING_T1_250ns |
76 INES_INITIAL_T1_2000ns, AUXMR);
77 retval = 250;
78 } else if (nano_sec <= 350) {
79 write_byte(nec_priv, INES_AUXD | INES_FOLLOWING_T1_350ns |
80 INES_INITIAL_T1_2000ns, AUXMR);
81 retval = 350;
82 } else {
83 write_byte(nec_priv, INES_AUXD | INES_FOLLOWING_T1_500ns |
84 INES_INITIAL_T1_2000ns, AUXMR);
85 retval = 500;
86 }
87
88 return retval;
89 }
90
num_in_fifo_bytes(struct ines_priv * ines_priv)91 static inline unsigned short num_in_fifo_bytes(struct ines_priv *ines_priv)
92 {
93 return ines_inb(ines_priv, IN_FIFO_COUNT);
94 }
95
pio_read(gpib_board_t * board,struct ines_priv * ines_priv,uint8_t * buffer,size_t length,size_t * nbytes)96 static ssize_t pio_read(gpib_board_t *board, struct ines_priv *ines_priv, uint8_t *buffer,
97 size_t length, size_t *nbytes)
98 {
99 ssize_t retval = 0;
100 unsigned int num_fifo_bytes, i;
101 struct nec7210_priv *nec_priv = &ines_priv->nec7210_priv;
102
103 *nbytes = 0;
104 while (*nbytes < length) {
105 if (wait_event_interruptible(board->wait,
106 num_in_fifo_bytes(ines_priv) ||
107 test_bit(RECEIVED_END_BN, &nec_priv->state) ||
108 test_bit(DEV_CLEAR_BN, &nec_priv->state) ||
109 test_bit(TIMO_NUM, &board->status))) {
110 pr_warn("gpib: pio read wait interrupted\n");
111 return -ERESTARTSYS;
112 }
113 if (test_bit(TIMO_NUM, &board->status))
114 return -ETIMEDOUT;
115 if (test_bit(DEV_CLEAR_BN, &nec_priv->state))
116 return -EINTR;
117
118 num_fifo_bytes = num_in_fifo_bytes(ines_priv);
119 if (num_fifo_bytes + *nbytes > length) {
120 pr_warn("ines: counter allowed %li extra byte(s)\n",
121 (long)(num_fifo_bytes - (length - *nbytes)));
122 num_fifo_bytes = length - *nbytes;
123 }
124 for (i = 0; i < num_fifo_bytes; i++)
125 buffer[(*nbytes)++] = read_byte(nec_priv, DIR);
126 if (test_bit(RECEIVED_END_BN, &nec_priv->state) &&
127 num_in_fifo_bytes(ines_priv) == 0)
128 break;
129 if (need_resched())
130 schedule();
131 }
132 /* make sure RECEIVED_END is in sync */
133 ines_interrupt(board);
134 return retval;
135 }
136
ines_accel_read(gpib_board_t * board,uint8_t * buffer,size_t length,int * end,size_t * bytes_read)137 int ines_accel_read(gpib_board_t *board, uint8_t *buffer,
138 size_t length, int *end, size_t *bytes_read)
139 {
140 ssize_t retval = 0;
141 struct ines_priv *ines_priv = board->private_data;
142 struct nec7210_priv *nec_priv = &ines_priv->nec7210_priv;
143 int counter_setting;
144
145 *end = 0;
146 *bytes_read = 0;
147 if (length == 0)
148 return 0;
149
150 clear_bit(DEV_CLEAR_BN, &nec_priv->state);
151
152 write_byte(nec_priv, INES_RFD_HLD_IMMEDIATE, AUXMR);
153
154 //clear in fifo
155 nec7210_set_reg_bits(nec_priv, ADMR, IN_FIFO_ENABLE_BIT, 0);
156 nec7210_set_reg_bits(nec_priv, ADMR, IN_FIFO_ENABLE_BIT, IN_FIFO_ENABLE_BIT);
157
158 ines_priv->extend_mode_bits |= LAST_BYTE_HANDLING_BIT;
159 ines_priv->extend_mode_bits &= ~XFER_COUNTER_OUTPUT_BIT & ~XFER_COUNTER_ENABLE_BIT;
160 ines_outb(ines_priv, ines_priv->extend_mode_bits, EXTEND_MODE);
161
162 counter_setting = length - num_in_fifo_bytes(ines_priv);
163 if (counter_setting > 0) {
164 ines_set_xfer_counter(ines_priv, length);
165 ines_priv->extend_mode_bits |= XFER_COUNTER_ENABLE_BIT;
166 ines_outb(ines_priv, ines_priv->extend_mode_bits, EXTEND_MODE);
167
168 // holdoff on END
169 nec7210_set_handshake_mode(board, nec_priv, HR_HLDE);
170 /* release rfd holdoff */
171 write_byte(nec_priv, AUX_FH, AUXMR);
172 }
173
174 retval = pio_read(board, ines_priv, buffer, length, bytes_read);
175 ines_priv->extend_mode_bits &= ~XFER_COUNTER_ENABLE_BIT;
176 ines_outb(ines_priv, ines_priv->extend_mode_bits, EXTEND_MODE);
177 if (retval < 0) {
178 write_byte(nec_priv, INES_RFD_HLD_IMMEDIATE, AUXMR);
179 return retval;
180 }
181 if (test_and_clear_bit(RECEIVED_END_BN, &nec_priv->state))
182 *end = 1;
183
184 return retval;
185 }
186
187 static const int out_fifo_size = 0xff;
188
num_out_fifo_bytes(struct ines_priv * ines_priv)189 static inline unsigned short num_out_fifo_bytes(struct ines_priv *ines_priv)
190 {
191 return ines_inb(ines_priv, OUT_FIFO_COUNT);
192 }
193
ines_write_wait(gpib_board_t * board,struct ines_priv * ines_priv,unsigned int fifo_threshold)194 static int ines_write_wait(gpib_board_t *board, struct ines_priv *ines_priv,
195 unsigned int fifo_threshold)
196 {
197 struct nec7210_priv *nec_priv = &ines_priv->nec7210_priv;
198
199 // wait until byte is ready to be sent
200 if (wait_event_interruptible(board->wait,
201 num_out_fifo_bytes(ines_priv) < fifo_threshold ||
202 test_bit(BUS_ERROR_BN, &nec_priv->state) ||
203 test_bit(DEV_CLEAR_BN, &nec_priv->state) ||
204 test_bit(TIMO_NUM, &board->status))) {
205 dev_dbg(board->gpib_dev, "gpib write interrupted\n");
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
ines_accel_write(gpib_board_t * board,uint8_t * buffer,size_t length,int send_eoi,size_t * bytes_written)218 int ines_accel_write(gpib_board_t *board, uint8_t *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
ines_pci_interrupt(int irq,void * arg)269 irqreturn_t ines_pci_interrupt(int irq, void *arg)
270 {
271 gpib_board_t *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
ines_interrupt(gpib_board_t * board)286 irqreturn_t ines_interrupt(gpib_board_t *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, EventIFC);
301 wake++;
302 }
303 if (isr3_bits & FIFO_ERROR_BIT)
304 pr_err("ines gpib: 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(gpib_board_t *board, const gpib_board_config_t *config);
319 static int ines_pci_accel_attach(gpib_board_t *board, const gpib_board_config_t *config);
320 static int ines_isa_attach(gpib_board_t *board, const gpib_board_config_t *config);
321
322 static void ines_pci_detach(gpib_board_t *board);
323 static void ines_isa_detach(gpib_board_t *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 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
ines_read(gpib_board_t * board,uint8_t * buffer,size_t length,int * end,size_t * bytes_read)398 int ines_read(gpib_board_t *board, uint8_t *buffer, size_t length, int *end, size_t *bytes_read)
399 {
400 struct ines_priv *priv = board->private_data;
401 struct nec7210_priv *nec_priv = &priv->nec7210_priv;
402 ssize_t retval;
403 int dummy;
404
405 retval = nec7210_read(board, &priv->nec7210_priv, buffer, length, end, bytes_read);
406 if (retval < 0) {
407 write_byte(nec_priv, INES_RFD_HLD_IMMEDIATE, AUXMR);
408
409 set_bit(RFD_HOLDOFF_BN, &nec_priv->state);
410
411 nec7210_read_data_in(board, nec_priv, &dummy);
412 }
413 return retval;
414 }
415
ines_write(gpib_board_t * board,uint8_t * buffer,size_t length,int send_eoi,size_t * bytes_written)416 int ines_write(gpib_board_t *board, uint8_t *buffer, size_t length, int send_eoi,
417 size_t *bytes_written)
418 {
419 struct ines_priv *priv = board->private_data;
420
421 return nec7210_write(board, &priv->nec7210_priv, buffer, length, send_eoi, bytes_written);
422 }
423
ines_command(gpib_board_t * board,uint8_t * buffer,size_t length,size_t * bytes_written)424 int ines_command(gpib_board_t *board, uint8_t *buffer, size_t length, size_t *bytes_written)
425 {
426 struct ines_priv *priv = board->private_data;
427
428 return nec7210_command(board, &priv->nec7210_priv, buffer, length, bytes_written);
429 }
430
ines_take_control(gpib_board_t * board,int synchronous)431 int ines_take_control(gpib_board_t *board, int synchronous)
432 {
433 struct ines_priv *priv = board->private_data;
434
435 return nec7210_take_control(board, &priv->nec7210_priv, synchronous);
436 }
437
ines_go_to_standby(gpib_board_t * board)438 int ines_go_to_standby(gpib_board_t *board)
439 {
440 struct ines_priv *priv = board->private_data;
441
442 return nec7210_go_to_standby(board, &priv->nec7210_priv);
443 }
444
ines_request_system_control(gpib_board_t * board,int request_control)445 void ines_request_system_control(gpib_board_t *board, int request_control)
446 {
447 struct ines_priv *priv = board->private_data;
448
449 nec7210_request_system_control(board, &priv->nec7210_priv, request_control);
450 }
451
ines_interface_clear(gpib_board_t * board,int assert)452 void ines_interface_clear(gpib_board_t *board, int assert)
453 {
454 struct ines_priv *priv = board->private_data;
455
456 nec7210_interface_clear(board, &priv->nec7210_priv, assert);
457 }
458
ines_remote_enable(gpib_board_t * board,int enable)459 void ines_remote_enable(gpib_board_t *board, int enable)
460 {
461 struct ines_priv *priv = board->private_data;
462
463 nec7210_remote_enable(board, &priv->nec7210_priv, enable);
464 }
465
ines_enable_eos(gpib_board_t * board,uint8_t eos_byte,int compare_8_bits)466 int ines_enable_eos(gpib_board_t *board, uint8_t eos_byte, int compare_8_bits)
467 {
468 struct ines_priv *priv = board->private_data;
469
470 return nec7210_enable_eos(board, &priv->nec7210_priv, eos_byte, compare_8_bits);
471 }
472
ines_disable_eos(gpib_board_t * board)473 void ines_disable_eos(gpib_board_t *board)
474 {
475 struct ines_priv *priv = board->private_data;
476
477 nec7210_disable_eos(board, &priv->nec7210_priv);
478 }
479
ines_update_status(gpib_board_t * board,unsigned int clear_mask)480 unsigned int ines_update_status(gpib_board_t *board, unsigned int clear_mask)
481 {
482 struct ines_priv *priv = board->private_data;
483
484 return nec7210_update_status(board, &priv->nec7210_priv, clear_mask);
485 }
486
ines_primary_address(gpib_board_t * board,unsigned int address)487 int ines_primary_address(gpib_board_t *board, unsigned int address)
488 {
489 struct ines_priv *priv = board->private_data;
490
491 return nec7210_primary_address(board, &priv->nec7210_priv, address);
492 }
493
ines_secondary_address(gpib_board_t * board,unsigned int address,int enable)494 int ines_secondary_address(gpib_board_t *board, unsigned int address, int enable)
495 {
496 struct ines_priv *priv = board->private_data;
497
498 return nec7210_secondary_address(board, &priv->nec7210_priv, address, enable);
499 }
500
ines_parallel_poll(gpib_board_t * board,uint8_t * result)501 int ines_parallel_poll(gpib_board_t *board, uint8_t *result)
502 {
503 struct ines_priv *priv = board->private_data;
504
505 return nec7210_parallel_poll(board, &priv->nec7210_priv, result);
506 }
507
ines_parallel_poll_configure(gpib_board_t * board,uint8_t config)508 void ines_parallel_poll_configure(gpib_board_t *board, uint8_t config)
509 {
510 struct ines_priv *priv = board->private_data;
511
512 nec7210_parallel_poll_configure(board, &priv->nec7210_priv, config);
513 }
514
ines_parallel_poll_response(gpib_board_t * board,int ist)515 void ines_parallel_poll_response(gpib_board_t *board, int ist)
516 {
517 struct ines_priv *priv = board->private_data;
518
519 nec7210_parallel_poll_response(board, &priv->nec7210_priv, ist);
520 }
521
ines_serial_poll_response(gpib_board_t * board,uint8_t status)522 void ines_serial_poll_response(gpib_board_t *board, uint8_t status)
523 {
524 struct ines_priv *priv = board->private_data;
525
526 nec7210_serial_poll_response(board, &priv->nec7210_priv, status);
527 }
528
ines_serial_poll_status(gpib_board_t * board)529 uint8_t ines_serial_poll_status(gpib_board_t *board)
530 {
531 struct ines_priv *priv = board->private_data;
532
533 return nec7210_serial_poll_status(board, &priv->nec7210_priv);
534 }
535
ines_return_to_local(gpib_board_t * board)536 void ines_return_to_local(gpib_board_t *board)
537 {
538 struct ines_priv *priv = board->private_data;
539
540 nec7210_return_to_local(board, &priv->nec7210_priv);
541 }
542
543 gpib_interface_t ines_pci_unaccel_interface = {
544 name: "ines_pci_unaccel",
545 attach : ines_pci_attach,
546 detach : ines_pci_detach,
547 read : ines_read,
548 write : ines_write,
549 command : ines_command,
550 take_control : ines_take_control,
551 go_to_standby : ines_go_to_standby,
552 request_system_control : ines_request_system_control,
553 interface_clear : ines_interface_clear,
554 remote_enable : ines_remote_enable,
555 enable_eos : ines_enable_eos,
556 disable_eos : ines_disable_eos,
557 parallel_poll : ines_parallel_poll,
558 parallel_poll_configure : ines_parallel_poll_configure,
559 parallel_poll_response : ines_parallel_poll_response,
560 local_parallel_poll_mode : NULL, // XXX
561 line_status : ines_line_status,
562 update_status : ines_update_status,
563 primary_address : ines_primary_address,
564 secondary_address : ines_secondary_address,
565 serial_poll_response : ines_serial_poll_response,
566 serial_poll_status : ines_serial_poll_status,
567 t1_delay : ines_t1_delay,
568 return_to_local : ines_return_to_local,
569 };
570
571 gpib_interface_t ines_pci_interface = {
572 name: "ines_pci",
573 attach : ines_pci_accel_attach,
574 detach : ines_pci_detach,
575 read : ines_accel_read,
576 write : ines_accel_write,
577 command : ines_command,
578 take_control : ines_take_control,
579 go_to_standby : ines_go_to_standby,
580 request_system_control : ines_request_system_control,
581 interface_clear : ines_interface_clear,
582 remote_enable : ines_remote_enable,
583 enable_eos : ines_enable_eos,
584 disable_eos : ines_disable_eos,
585 parallel_poll : ines_parallel_poll,
586 parallel_poll_configure : ines_parallel_poll_configure,
587 parallel_poll_response : ines_parallel_poll_response,
588 local_parallel_poll_mode : NULL, // XXX
589 line_status : ines_line_status,
590 update_status : ines_update_status,
591 primary_address : ines_primary_address,
592 secondary_address : ines_secondary_address,
593 serial_poll_response : ines_serial_poll_response,
594 serial_poll_status : ines_serial_poll_status,
595 t1_delay : ines_t1_delay,
596 return_to_local : ines_return_to_local,
597 };
598
599 gpib_interface_t ines_pci_accel_interface = {
600 name: "ines_pci_accel",
601 attach : ines_pci_accel_attach,
602 detach : ines_pci_detach,
603 read : ines_accel_read,
604 write : ines_accel_write,
605 command : ines_command,
606 take_control : ines_take_control,
607 go_to_standby : ines_go_to_standby,
608 request_system_control : ines_request_system_control,
609 interface_clear : ines_interface_clear,
610 remote_enable : ines_remote_enable,
611 enable_eos : ines_enable_eos,
612 disable_eos : ines_disable_eos,
613 parallel_poll : ines_parallel_poll,
614 parallel_poll_configure : ines_parallel_poll_configure,
615 parallel_poll_response : ines_parallel_poll_response,
616 local_parallel_poll_mode : NULL, // XXX
617 line_status : ines_line_status,
618 update_status : ines_update_status,
619 primary_address : ines_primary_address,
620 secondary_address : ines_secondary_address,
621 serial_poll_response : ines_serial_poll_response,
622 serial_poll_status : ines_serial_poll_status,
623 t1_delay : ines_t1_delay,
624 return_to_local : ines_return_to_local,
625 };
626
627 gpib_interface_t ines_isa_interface = {
628 name: "ines_isa",
629 attach : ines_isa_attach,
630 detach : ines_isa_detach,
631 read : ines_accel_read,
632 write : ines_accel_write,
633 command : ines_command,
634 take_control : ines_take_control,
635 go_to_standby : ines_go_to_standby,
636 request_system_control : ines_request_system_control,
637 interface_clear : ines_interface_clear,
638 remote_enable : ines_remote_enable,
639 enable_eos : ines_enable_eos,
640 disable_eos : ines_disable_eos,
641 parallel_poll : ines_parallel_poll,
642 parallel_poll_configure : ines_parallel_poll_configure,
643 parallel_poll_response : ines_parallel_poll_response,
644 local_parallel_poll_mode : NULL, // XXX
645 line_status : ines_line_status,
646 update_status : ines_update_status,
647 primary_address : ines_primary_address,
648 secondary_address : ines_secondary_address,
649 serial_poll_response : ines_serial_poll_response,
650 serial_poll_status : ines_serial_poll_status,
651 t1_delay : ines_t1_delay,
652 return_to_local : ines_return_to_local,
653 };
654
ines_allocate_private(gpib_board_t * board)655 static int ines_allocate_private(gpib_board_t *board)
656 {
657 struct ines_priv *priv;
658
659 board->private_data = kmalloc(sizeof(struct ines_priv), GFP_KERNEL);
660 if (!board->private_data)
661 return -1;
662 priv = board->private_data;
663 memset(priv, 0, sizeof(struct ines_priv));
664 init_nec7210_private(&priv->nec7210_priv);
665 return 0;
666 }
667
ines_free_private(gpib_board_t * board)668 void ines_free_private(gpib_board_t *board)
669 {
670 kfree(board->private_data);
671 board->private_data = NULL;
672 }
673
ines_generic_attach(gpib_board_t * board)674 int ines_generic_attach(gpib_board_t *board)
675 {
676 struct ines_priv *ines_priv;
677 struct nec7210_priv *nec_priv;
678
679 board->status = 0;
680
681 if (ines_allocate_private(board))
682 return -ENOMEM;
683 ines_priv = board->private_data;
684 nec_priv = &ines_priv->nec7210_priv;
685 nec_priv->read_byte = nec7210_ioport_read_byte;
686 nec_priv->write_byte = nec7210_ioport_write_byte;
687 nec_priv->offset = 1;
688 nec_priv->type = IGPIB7210;
689 ines_priv->pci_chip_type = PCI_CHIP_NONE;
690
691 return 0;
692 }
693
ines_online(struct ines_priv * ines_priv,const gpib_board_t * board,int use_accel)694 void ines_online(struct ines_priv *ines_priv, const gpib_board_t *board, int use_accel)
695 {
696 struct nec7210_priv *nec_priv = &ines_priv->nec7210_priv;
697
698 /* ines doesn't seem to use internal count register */
699 write_byte(nec_priv, ICR | 0, AUXMR);
700
701 write_byte(nec_priv, INES_AUX_XMODE, AUXMR);
702 write_byte(nec_priv, INES_RFD_HLD_IMMEDIATE, AUXMR);
703
704 set_bit(RFD_HOLDOFF_BN, &nec_priv->state);
705
706 write_byte(nec_priv, INES_AUXD | 0, AUXMR);
707 ines_outb(ines_priv, 0, XDMA_CONTROL);
708 ines_priv->extend_mode_bits = 0;
709 ines_outb(ines_priv, ines_priv->extend_mode_bits, EXTEND_MODE);
710 if (use_accel) {
711 ines_outb(ines_priv, 0x80, OUT_FIFO_WATERMARK);
712 ines_outb(ines_priv, 0x80, IN_FIFO_WATERMARK);
713 ines_outb(ines_priv, IFC_ACTIVE_BIT | ATN_ACTIVE_BIT |
714 FIFO_ERROR_BIT | XFER_COUNT_BIT, IMR3);
715 ines_outb(ines_priv, IN_FIFO_WATERMARK_BIT | IN_FIFO_FULL_BIT |
716 OUT_FIFO_WATERMARK_BIT | OUT_FIFO_EMPTY_BIT, IMR4);
717 } else {
718 nec7210_set_reg_bits(nec_priv, ADMR, IN_FIFO_ENABLE_BIT | OUT_FIFO_ENABLE_BIT, 0);
719 ines_outb(ines_priv, IFC_ACTIVE_BIT | FIFO_ERROR_BIT, IMR3);
720 ines_outb(ines_priv, 0, IMR4);
721 }
722
723 nec7210_board_online(nec_priv, board);
724 if (use_accel)
725 nec7210_set_reg_bits(nec_priv, IMR1, HR_DOIE | HR_DIIE, 0);
726 }
727
ines_common_pci_attach(gpib_board_t * board,const gpib_board_config_t * config)728 static int ines_common_pci_attach(gpib_board_t *board, const gpib_board_config_t *config)
729 {
730 struct ines_priv *ines_priv;
731 struct nec7210_priv *nec_priv;
732 int isr_flags = 0;
733 int retval;
734 struct ines_pci_id found_id;
735 unsigned int i;
736 struct pci_dev *pdev;
737
738 memset(&found_id, 0, sizeof(found_id));
739
740 retval = ines_generic_attach(board);
741 if (retval)
742 return retval;
743
744 ines_priv = board->private_data;
745 nec_priv = &ines_priv->nec7210_priv;
746
747 // find board
748 ines_priv->pci_device = NULL;
749 for (i = 0; i < num_pci_chips && !ines_priv->pci_device; i++) {
750 pdev = NULL;
751 do {
752 if (pci_ids[i].subsystem_vendor_id >= 0 &&
753 pci_ids[i].subsystem_device_id >= 0)
754 pdev = pci_get_subsys(pci_ids[i].vendor_id, pci_ids[i].device_id,
755 pci_ids[i].subsystem_vendor_id,
756 pci_ids[i].subsystem_device_id, pdev);
757 else
758 pdev = pci_get_device(pci_ids[i].vendor_id, pci_ids[i].device_id,
759 pdev);
760 if (!pdev)
761 break;
762 if (config->pci_bus >= 0 && config->pci_bus != pdev->bus->number)
763 continue;
764 if (config->pci_slot >= 0 && config->pci_slot != PCI_SLOT(pdev->devfn))
765 continue;
766 found_id = pci_ids[i];
767 ines_priv->pci_device = pdev;
768 break;
769 } while (1);
770 }
771 if (!ines_priv->pci_device) {
772 pr_err("gpib: could not find ines PCI board\n");
773 return -1;
774 }
775
776 if (pci_enable_device(ines_priv->pci_device)) {
777 pr_err("error enabling pci device\n");
778 return -1;
779 }
780
781 if (pci_request_regions(ines_priv->pci_device, "ines-gpib"))
782 return -1;
783 nec_priv->iobase = pci_resource_start(ines_priv->pci_device,
784 found_id.gpib_region);
785
786 ines_priv->pci_chip_type = found_id.pci_chip_type;
787 nec_priv->offset = found_id.io_offset;
788 switch (ines_priv->pci_chip_type) {
789 case PCI_CHIP_PLX9050:
790 ines_priv->plx_iobase = pci_resource_start(ines_priv->pci_device, 1);
791 break;
792 case PCI_CHIP_AMCC5920:
793 ines_priv->amcc_iobase = pci_resource_start(ines_priv->pci_device, 0);
794 break;
795 case PCI_CHIP_QUANCOM:
796 break;
797 case PCI_CHIP_QUICKLOGIC5030:
798 break;
799 default:
800 pr_err("gpib: unspecified chip type? (bug)\n");
801 nec_priv->iobase = 0;
802 pci_release_regions(ines_priv->pci_device);
803 return -1;
804 }
805
806 nec7210_board_reset(nec_priv, board);
807 #ifdef QUANCOM_PCI
808 if (ines_priv->pci_chip_type == PCI_CHIP_QUANCOM) {
809 /* change interrupt polarity */
810 nec_priv->auxb_bits |= HR_INV;
811 ines_outb(ines_priv, nec_priv->auxb_bits, AUXMR);
812 }
813 #endif
814 isr_flags |= IRQF_SHARED;
815 if (request_irq(ines_priv->pci_device->irq, ines_pci_interrupt, isr_flags,
816 "pci-gpib", board)) {
817 pr_err("gpib: can't request IRQ %d\n", ines_priv->pci_device->irq);
818 return -1;
819 }
820 ines_priv->irq = ines_priv->pci_device->irq;
821
822 // enable interrupts on pci chip
823 switch (ines_priv->pci_chip_type) {
824 case PCI_CHIP_PLX9050:
825 outl(PLX9050_LINTR1_EN_BIT | PLX9050_LINTR1_POLARITY_BIT | PLX9050_PCI_INTR_EN_BIT,
826 ines_priv->plx_iobase + PLX9050_INTCSR_REG);
827 break;
828 case PCI_CHIP_AMCC5920:
829 {
830 static const int region = 1;
831 static const int num_wait_states = 7;
832 u32 bits;
833
834 bits = amcc_prefetch_bits(region, PREFETCH_DISABLED);
835 bits |= amcc_PTADR_mode_bit(region);
836 bits |= amcc_disable_write_fifo_bit(region);
837 bits |= amcc_wait_state_bits(region, num_wait_states);
838 outl(bits, ines_priv->amcc_iobase + AMCC_PASS_THRU_REG);
839 outl(AMCC_ADDON_INTR_ENABLE_BIT, ines_priv->amcc_iobase + AMCC_INTCS_REG);
840 }
841 break;
842 case PCI_CHIP_QUANCOM:
843 outb(QUANCOM_IRQ_ENABLE_BIT, nec_priv->iobase +
844 QUANCOM_IRQ_CONTROL_STATUS_REG);
845 break;
846 case PCI_CHIP_QUICKLOGIC5030:
847 break;
848 default:
849 pr_err("gpib: unspecified chip type? (bug)\n");
850 return -1;
851 }
852
853 return 0;
854 }
855
ines_pci_attach(gpib_board_t * board,const gpib_board_config_t * config)856 int ines_pci_attach(gpib_board_t *board, const gpib_board_config_t *config)
857 {
858 struct ines_priv *ines_priv;
859 int retval;
860
861 retval = ines_common_pci_attach(board, config);
862 if (retval < 0)
863 return retval;
864
865 ines_priv = board->private_data;
866 ines_online(ines_priv, board, 0);
867
868 return 0;
869 }
870
ines_pci_accel_attach(gpib_board_t * board,const gpib_board_config_t * config)871 int ines_pci_accel_attach(gpib_board_t *board, const gpib_board_config_t *config)
872 {
873 struct ines_priv *ines_priv;
874 int retval;
875
876 retval = ines_common_pci_attach(board, config);
877 if (retval < 0)
878 return retval;
879
880 ines_priv = board->private_data;
881 ines_online(ines_priv, board, 1);
882
883 return 0;
884 }
885
886 static const int ines_isa_iosize = 0x20;
887
ines_isa_attach(gpib_board_t * board,const gpib_board_config_t * config)888 int ines_isa_attach(gpib_board_t *board, const gpib_board_config_t *config)
889 {
890 struct ines_priv *ines_priv;
891 struct nec7210_priv *nec_priv;
892 int isr_flags = 0;
893 int retval;
894
895 retval = ines_generic_attach(board);
896 if (retval)
897 return retval;
898
899 ines_priv = board->private_data;
900 nec_priv = &ines_priv->nec7210_priv;
901
902 if (!request_region(config->ibbase, ines_isa_iosize, "ines_gpib")) {
903 pr_err("ines_gpib: ioports at 0x%x already in use\n", config->ibbase);
904 return -1;
905 }
906 nec_priv->iobase = config->ibbase;
907 nec_priv->offset = 1;
908 nec7210_board_reset(nec_priv, board);
909 if (request_irq(config->ibirq, ines_pci_interrupt, isr_flags, "ines_gpib", board)) {
910 pr_err("ines_gpib: failed to allocate IRQ %d\n", config->ibirq);
911 return -1;
912 }
913 ines_priv->irq = config->ibirq;
914 ines_online(ines_priv, board, 1);
915 return 0;
916 }
917
ines_pci_detach(gpib_board_t * board)918 void ines_pci_detach(gpib_board_t *board)
919 {
920 struct ines_priv *ines_priv = board->private_data;
921 struct nec7210_priv *nec_priv;
922
923 if (ines_priv) {
924 nec_priv = &ines_priv->nec7210_priv;
925 if (ines_priv->irq) {
926 // disable interrupts
927 switch (ines_priv->pci_chip_type) {
928 case PCI_CHIP_AMCC5920:
929 if (ines_priv->plx_iobase)
930 outl(0, ines_priv->plx_iobase + PLX9050_INTCSR_REG);
931 break;
932 case PCI_CHIP_QUANCOM:
933 if (nec_priv->iobase)
934 outb(0, nec_priv->iobase +
935 QUANCOM_IRQ_CONTROL_STATUS_REG);
936 break;
937 default:
938 break;
939 }
940 free_irq(ines_priv->irq, board);
941 }
942 if (nec_priv->iobase) {
943 nec7210_board_reset(nec_priv, board);
944 pci_release_regions(ines_priv->pci_device);
945 }
946 if (ines_priv->pci_device)
947 pci_dev_put(ines_priv->pci_device);
948 }
949 ines_free_private(board);
950 }
951
ines_isa_detach(gpib_board_t * board)952 void ines_isa_detach(gpib_board_t *board)
953 {
954 struct ines_priv *ines_priv = board->private_data;
955 struct nec7210_priv *nec_priv;
956
957 if (ines_priv) {
958 nec_priv = &ines_priv->nec7210_priv;
959 if (ines_priv->irq)
960 free_irq(ines_priv->irq, board);
961 if (nec_priv->iobase) {
962 nec7210_board_reset(nec_priv, board);
963 release_region(nec_priv->iobase, ines_isa_iosize);
964 }
965 }
966 ines_free_private(board);
967 }
968
ines_pci_probe(struct pci_dev * dev,const struct pci_device_id * id)969 static int ines_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
970 {
971 return 0;
972 }
973
974 static struct pci_driver ines_pci_driver = {
975 .name = "ines_gpib",
976 .id_table = ines_pci_table,
977 .probe = &ines_pci_probe
978 };
979
980 #ifdef GPIB_PCMCIA
981
982 #include <linux/kernel.h>
983 #include <linux/ptrace.h>
984 #include <linux/string.h>
985 #include <linux/timer.h>
986
987 #include <pcmcia/cistpl.h>
988 #include <pcmcia/ds.h>
989 #include <pcmcia/cisreg.h>
990
991 #ifdef PCMCIA_DEBUG
992 static int pc_debug = PCMCIA_DEBUG;
993 #define DEBUG(n, args...) do {if (pc_debug > (n)) pr_debug(args)} while (0)
994 #else
995 #define DEBUG(args...)
996 #endif
997
998 static const int ines_pcmcia_iosize = 0x20;
999
1000 /* The event() function is this driver's Card Services event handler.
1001 * It will be called by Card Services when an appropriate card status
1002 * event is received. The config() and release() entry points are
1003 * used to configure or release a socket, in response to card insertion
1004 * and ejection events. They are invoked from the gpib event
1005 * handler.
1006 */
1007
1008 static int ines_gpib_config(struct pcmcia_device *link);
1009 static void ines_gpib_release(struct pcmcia_device *link);
1010 static int ines_pcmcia_attach(gpib_board_t *board, const gpib_board_config_t *config);
1011 static int ines_pcmcia_accel_attach(gpib_board_t *board, const gpib_board_config_t *config);
1012 static void ines_pcmcia_detach(gpib_board_t *board);
1013 static irqreturn_t ines_pcmcia_interrupt(int irq, void *arg);
1014 static int ines_common_pcmcia_attach(gpib_board_t *board);
1015 /*
1016 * A linked list of "instances" of the gpib device. Each actual
1017 * PCMCIA card corresponds to one device instance, and is described
1018 * by one dev_link_t structure (defined in ds.h).
1019 *
1020 * You may not want to use a linked list for this -- for example, the
1021 * memory card driver uses an array of dev_link_t pointers, where minor
1022 * device numbers are used to derive the corresponding array index.
1023 */
1024
1025 static struct pcmcia_device *curr_dev;
1026
1027 /*
1028 * A dev_link_t structure has fields for most things that are needed
1029 * to keep track of a socket, but there will usually be some device
1030 * specific information that also needs to be kept track of. The
1031 * 'priv' pointer in a dev_link_t structure can be used to point to
1032 * a device-specific private data structure, like this.
1033 *
1034 * A driver needs to provide a dev_node_t structure for each device
1035 * on a card. In some cases, there is only one device per card (for
1036 * example, ethernet cards, modems). In other cases, there may be
1037 * many actual or logical devices (SCSI adapters, memory cards with
1038 * multiple partitions). The dev_node_t structures need to be kept
1039 * in a linked list starting at the 'dev' field of a dev_link_t
1040 * structure. We allocate them in the card's private data structure,
1041 * because they generally can't be allocated dynamically.
1042 */
1043
1044 struct local_info {
1045 struct pcmcia_device *p_dev;
1046 gpib_board_t *dev;
1047 u_short manfid;
1048 u_short cardid;
1049 };
1050
1051 /*
1052 * gpib_attach() creates an "instance" of the driver, allocating
1053 * local data structures for one device. The device is registered
1054 * with Card Services.
1055 *
1056 * The dev_link structure is initialized, but we don't actually
1057 * configure the card at this point -- we wait until we receive a
1058 * card insertion event.
1059 */
ines_gpib_probe(struct pcmcia_device * link)1060 static int ines_gpib_probe(struct pcmcia_device *link)
1061 {
1062 struct local_info *info;
1063
1064 // int ret, i;
1065
1066 DEBUG(0, "%s(0x%p)\n", __func__ link);
1067
1068 /* Allocate space for private device-specific data */
1069 info = kzalloc(sizeof(*info), GFP_KERNEL);
1070 if (!info)
1071 return -ENOMEM;
1072
1073 info->p_dev = link;
1074 link->priv = info;
1075
1076 /* The io structure describes IO port mapping */
1077 link->resource[0]->end = 32;
1078 link->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
1079 link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
1080 link->io_lines = 5;
1081
1082 /* General socket configuration */
1083 link->config_flags = CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
1084
1085 /* Register with Card Services */
1086 curr_dev = link;
1087 return ines_gpib_config(link);
1088 }
1089
1090 /*
1091 * This deletes a driver "instance". The device is de-registered
1092 * with Card Services. If it has been released, all local data
1093 * structures are freed. Otherwise, the structures will be freed
1094 * when the device is released.
1095 */
ines_gpib_remove(struct pcmcia_device * link)1096 static void ines_gpib_remove(struct pcmcia_device *link)
1097 {
1098 struct local_info *info = link->priv;
1099 //struct gpib_board_t *dev = info->dev;
1100
1101 DEBUG(0, "%s(0x%p)\n", __func__, link);
1102
1103 if (info->dev)
1104 ines_pcmcia_detach(info->dev);
1105 ines_gpib_release(link);
1106
1107 //free_netdev(dev);
1108 kfree(info);
1109 }
1110
ines_gpib_config_iteration(struct pcmcia_device * link,void * priv_data)1111 static int ines_gpib_config_iteration(struct pcmcia_device *link, void *priv_data)
1112 {
1113 return pcmcia_request_io(link);
1114 }
1115
1116 /*
1117 * gpib_config() is scheduled to run after a CARD_INSERTION event
1118 * is received, to configure the PCMCIA socket, and to make the
1119 * device available to the system.
1120 */
ines_gpib_config(struct pcmcia_device * link)1121 static int ines_gpib_config(struct pcmcia_device *link)
1122 {
1123 struct local_info *dev;
1124 int retval;
1125 void *virt;
1126
1127 dev = link->priv;
1128 DEBUG(0, "%s(0x%p)\n", __func__, link);
1129
1130 retval = pcmcia_loop_config(link, &ines_gpib_config_iteration, NULL);
1131 if (retval) {
1132 dev_warn(&link->dev, "no configuration found\n");
1133 ines_gpib_release(link);
1134 return -ENODEV;
1135 }
1136
1137 pr_debug("ines_cs: manufacturer: 0x%x card: 0x%x\n",
1138 link->manf_id, link->card_id);
1139
1140 /* for the ines card we have to setup the configuration registers in
1141 * attribute memory here
1142 */
1143 link->resource[2]->flags |= WIN_MEMORY_TYPE_AM | WIN_DATA_WIDTH_8 | WIN_ENABLE;
1144 link->resource[2]->end = 0x1000;
1145 retval = pcmcia_request_window(link, link->resource[2], 250);
1146 if (retval) {
1147 dev_warn(&link->dev, "pcmcia_request_window failed\n");
1148 ines_gpib_release(link);
1149 return -ENODEV;
1150 }
1151 retval = pcmcia_map_mem_page(link, link->resource[2], 0);
1152 if (retval) {
1153 dev_warn(&link->dev, "pcmcia_map_mem_page failed\n");
1154 ines_gpib_release(link);
1155 return -ENODEV;
1156 }
1157 virt = ioremap(link->resource[2]->start, resource_size(link->resource[2]));
1158 writeb((link->resource[2]->start >> 2) & 0xff, virt + 0xf0); // IOWindow base
1159 iounmap((void *)virt);
1160
1161 /*
1162 * This actually configures the PCMCIA socket -- setting up
1163 * the I/O windows and the interrupt mapping.
1164 */
1165 retval = pcmcia_enable_device(link);
1166 if (retval) {
1167 ines_gpib_release(link);
1168 return -ENODEV;
1169 }
1170 pr_info("ines gpib device loaded\n");
1171 return 0;
1172 } /* gpib_config */
1173
1174 /*
1175 * After a card is removed, gpib_release() will unregister the net
1176 * device, and release the PCMCIA configuration. If the device is
1177 * still open, this will be postponed until it is closed.
1178 */
1179
ines_gpib_release(struct pcmcia_device * link)1180 static void ines_gpib_release(struct pcmcia_device *link)
1181 {
1182 DEBUG(0, "%s(0x%p)\n", __func__, link);
1183 pcmcia_disable_device(link);
1184 } /* gpib_release */
1185
ines_gpib_suspend(struct pcmcia_device * link)1186 static int ines_gpib_suspend(struct pcmcia_device *link)
1187 {
1188 //struct local_info *info = link->priv;
1189 //struct gpib_board_t *dev = info->dev;
1190 DEBUG(0, "%s(0x%p)\n", __func__, link);
1191
1192 if (link->open)
1193 pr_err("Device still open ???\n");
1194 //netif_device_detach(dev);
1195
1196 return 0;
1197 }
1198
ines_gpib_resume(struct pcmcia_device * link)1199 static int ines_gpib_resume(struct pcmcia_device *link)
1200 {
1201 //struct local_info_t *info = link->priv;
1202 //struct gpib_board_t *dev = info->dev;
1203 DEBUG(0, "%s(0x%p)\n", __func__, link);
1204
1205 /*if (link->open) {
1206 * ni_gpib_probe(dev); / really?
1207 * printk("Gpib resumed ???\n");
1208 * //netif_device_attach(dev);
1209 *}
1210 */
1211 return ines_gpib_config(link);
1212 }
1213
1214 static struct pcmcia_device_id ines_pcmcia_ids[] = {
1215 PCMCIA_DEVICE_MANF_CARD(0x01b4, 0x4730),
1216 PCMCIA_DEVICE_NULL
1217 };
1218 MODULE_DEVICE_TABLE(pcmcia, ines_pcmcia_ids);
1219
1220 static struct pcmcia_driver ines_gpib_cs_driver = {
1221 .owner = THIS_MODULE,
1222 .name = "ines_gpib_cs",
1223 .id_table = ines_pcmcia_ids,
1224 .probe = ines_gpib_probe,
1225 .remove = ines_gpib_remove,
1226 .suspend = ines_gpib_suspend,
1227 .resume = ines_gpib_resume,
1228 };
1229
ines_pcmcia_init_module(void)1230 int ines_pcmcia_init_module(void)
1231 {
1232 pcmcia_register_driver(&ines_gpib_cs_driver);
1233 return 0;
1234 }
1235
ines_pcmcia_cleanup_module(void)1236 void ines_pcmcia_cleanup_module(void)
1237 {
1238 DEBUG(0, "ines_cs: unloading\n");
1239 pcmcia_unregister_driver(&ines_gpib_cs_driver);
1240 }
1241
1242 gpib_interface_t ines_pcmcia_unaccel_interface = {
1243 name: "ines_pcmcia_unaccel",
1244 attach : ines_pcmcia_attach,
1245 detach : ines_pcmcia_detach,
1246 read : ines_read,
1247 write : ines_write,
1248 command : ines_command,
1249 take_control : ines_take_control,
1250 go_to_standby : ines_go_to_standby,
1251 request_system_control : ines_request_system_control,
1252 interface_clear : ines_interface_clear,
1253 remote_enable : ines_remote_enable,
1254 enable_eos : ines_enable_eos,
1255 disable_eos : ines_disable_eos,
1256 parallel_poll : ines_parallel_poll,
1257 parallel_poll_configure : ines_parallel_poll_configure,
1258 parallel_poll_response : ines_parallel_poll_response,
1259 local_parallel_poll_mode : NULL, // XXX
1260 line_status : ines_line_status,
1261 update_status : ines_update_status,
1262 primary_address : ines_primary_address,
1263 secondary_address : ines_secondary_address,
1264 serial_poll_response : ines_serial_poll_response,
1265 serial_poll_status : ines_serial_poll_status,
1266 t1_delay : ines_t1_delay,
1267 return_to_local : ines_return_to_local,
1268 };
1269
1270 gpib_interface_t ines_pcmcia_accel_interface = {
1271 name: "ines_pcmcia_accel",
1272 attach : ines_pcmcia_accel_attach,
1273 detach : ines_pcmcia_detach,
1274 read : ines_accel_read,
1275 write : ines_accel_write,
1276 command : ines_command,
1277 take_control : ines_take_control,
1278 go_to_standby : ines_go_to_standby,
1279 request_system_control : ines_request_system_control,
1280 interface_clear : ines_interface_clear,
1281 remote_enable : ines_remote_enable,
1282 enable_eos : ines_enable_eos,
1283 disable_eos : ines_disable_eos,
1284 parallel_poll : ines_parallel_poll,
1285 parallel_poll_configure : ines_parallel_poll_configure,
1286 parallel_poll_response : ines_parallel_poll_response,
1287 local_parallel_poll_mode : NULL, // XXX
1288 line_status : ines_line_status,
1289 update_status : ines_update_status,
1290 primary_address : ines_primary_address,
1291 secondary_address : ines_secondary_address,
1292 serial_poll_response : ines_serial_poll_response,
1293 serial_poll_status : ines_serial_poll_status,
1294 t1_delay : ines_t1_delay,
1295 return_to_local : ines_return_to_local,
1296 };
1297
1298 gpib_interface_t ines_pcmcia_interface = {
1299 name: "ines_pcmcia",
1300 attach : ines_pcmcia_accel_attach,
1301 detach : ines_pcmcia_detach,
1302 read : ines_accel_read,
1303 write : ines_accel_write,
1304 command : ines_command,
1305 take_control : ines_take_control,
1306 go_to_standby : ines_go_to_standby,
1307 request_system_control : ines_request_system_control,
1308 interface_clear : ines_interface_clear,
1309 remote_enable : ines_remote_enable,
1310 enable_eos : ines_enable_eos,
1311 disable_eos : ines_disable_eos,
1312 parallel_poll : ines_parallel_poll,
1313 parallel_poll_configure : ines_parallel_poll_configure,
1314 parallel_poll_response : ines_parallel_poll_response,
1315 local_parallel_poll_mode : NULL, // XXX
1316 line_status : ines_line_status,
1317 update_status : ines_update_status,
1318 primary_address : ines_primary_address,
1319 secondary_address : ines_secondary_address,
1320 serial_poll_response : ines_serial_poll_response,
1321 serial_poll_status : ines_serial_poll_status,
1322 t1_delay : ines_t1_delay,
1323 return_to_local : ines_return_to_local,
1324 };
1325
ines_pcmcia_interrupt(int irq,void * arg)1326 irqreturn_t ines_pcmcia_interrupt(int irq, void *arg)
1327 {
1328 gpib_board_t *board = arg;
1329
1330 return ines_interrupt(board);
1331 }
1332
ines_common_pcmcia_attach(gpib_board_t * board)1333 int ines_common_pcmcia_attach(gpib_board_t *board)
1334 {
1335 struct ines_priv *ines_priv;
1336 struct nec7210_priv *nec_priv;
1337 int retval;
1338
1339 if (!curr_dev) {
1340 pr_err("no ines pcmcia cards found\n");
1341 return -1;
1342 }
1343
1344 retval = ines_generic_attach(board);
1345 if (retval)
1346 return retval;
1347
1348 ines_priv = board->private_data;
1349 nec_priv = &ines_priv->nec7210_priv;
1350
1351 if (request_region(curr_dev->resource[0]->start,
1352 resource_size(curr_dev->resource[0]), "ines_gpib") == 0) {
1353 pr_err("ines_gpib: ioports at 0x%lx already in use\n",
1354 (unsigned long)(curr_dev->resource[0]->start));
1355 return -1;
1356 }
1357
1358 nec_priv->iobase = curr_dev->resource[0]->start;
1359
1360 nec7210_board_reset(nec_priv, board);
1361
1362 if (request_irq(curr_dev->irq, ines_pcmcia_interrupt, IRQF_SHARED,
1363 "pcmcia-gpib", board)) {
1364 pr_err("gpib: can't request IRQ %d\n", curr_dev->irq);
1365 return -1;
1366 }
1367 ines_priv->irq = curr_dev->irq;
1368
1369 return 0;
1370 }
1371
ines_pcmcia_attach(gpib_board_t * board,const gpib_board_config_t * config)1372 int ines_pcmcia_attach(gpib_board_t *board, const gpib_board_config_t *config)
1373 {
1374 struct ines_priv *ines_priv;
1375 int retval;
1376
1377 retval = ines_common_pcmcia_attach(board);
1378 if (retval < 0)
1379 return retval;
1380
1381 ines_priv = board->private_data;
1382 ines_online(ines_priv, board, 0);
1383
1384 return 0;
1385 }
1386
ines_pcmcia_accel_attach(gpib_board_t * board,const gpib_board_config_t * config)1387 int ines_pcmcia_accel_attach(gpib_board_t *board, const gpib_board_config_t *config)
1388 {
1389 struct ines_priv *ines_priv;
1390 int retval;
1391
1392 retval = ines_common_pcmcia_attach(board);
1393 if (retval < 0)
1394 return retval;
1395
1396 ines_priv = board->private_data;
1397 ines_online(ines_priv, board, 1);
1398
1399 return 0;
1400 }
1401
ines_pcmcia_detach(gpib_board_t * board)1402 void ines_pcmcia_detach(gpib_board_t *board)
1403 {
1404 struct ines_priv *ines_priv = board->private_data;
1405 struct nec7210_priv *nec_priv;
1406
1407 if (ines_priv) {
1408 nec_priv = &ines_priv->nec7210_priv;
1409 if (ines_priv->irq)
1410 free_irq(ines_priv->irq, board);
1411 if (nec_priv->iobase) {
1412 nec7210_board_reset(nec_priv, board);
1413 release_region(nec_priv->iobase, ines_pcmcia_iosize);
1414 }
1415 }
1416 ines_free_private(board);
1417 }
1418
1419 #endif /* GPIB_PCMCIA */
1420
ines_init_module(void)1421 static int __init ines_init_module(void)
1422 {
1423 int err = 0;
1424
1425 err = pci_register_driver(&ines_pci_driver);
1426 if (err) {
1427 pr_err("ines_gpib: pci_driver_register failed!\n");
1428 return err;
1429 }
1430
1431 gpib_register_driver(&ines_pci_interface, THIS_MODULE);
1432 gpib_register_driver(&ines_pci_unaccel_interface, THIS_MODULE);
1433 gpib_register_driver(&ines_pci_accel_interface, THIS_MODULE);
1434 gpib_register_driver(&ines_isa_interface, THIS_MODULE);
1435 #ifdef GPIB_PCMCIA
1436 gpib_register_driver(&ines_pcmcia_interface, THIS_MODULE);
1437 gpib_register_driver(&ines_pcmcia_unaccel_interface, THIS_MODULE);
1438 gpib_register_driver(&ines_pcmcia_accel_interface, THIS_MODULE);
1439 err += ines_pcmcia_init_module();
1440 #endif
1441 if (err)
1442 return -1;
1443
1444 return 0;
1445 }
1446
ines_exit_module(void)1447 static void __exit ines_exit_module(void)
1448 {
1449 gpib_unregister_driver(&ines_pci_interface);
1450 gpib_unregister_driver(&ines_pci_unaccel_interface);
1451 gpib_unregister_driver(&ines_pci_accel_interface);
1452 gpib_unregister_driver(&ines_isa_interface);
1453 #ifdef GPIB__PCMCIA
1454 gpib_unregister_driver(&ines_pcmcia_interface);
1455 gpib_unregister_driver(&ines_pcmcia_unaccel_interface);
1456 gpib_unregister_driver(&ines_pcmcia_accel_interface);
1457 ines_pcmcia_cleanup_module();
1458 #endif
1459
1460 pci_unregister_driver(&ines_pci_driver);
1461 }
1462
1463 module_init(ines_init_module);
1464 module_exit(ines_exit_module);
1465