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