1 // SPDX-License-Identifier: GPL-2.0 2 3 /*************************************************************************** 4 * driver for Agilent 82357A/B usb to gpib adapters * 5 * copyright : (C) 2004 by Frank Mori Hess * 6 ***************************************************************************/ 7 8 #define _GNU_SOURCE 9 10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 11 #define dev_fmt pr_fmt 12 #define DRV_NAME KBUILD_MODNAME 13 14 #include <linux/kernel.h> 15 #include <linux/module.h> 16 #include <linux/slab.h> 17 #include "agilent_82357a.h" 18 #include "gpibP.h" 19 #include "tms9914.h" 20 21 MODULE_LICENSE("GPL"); 22 MODULE_DESCRIPTION("GPIB driver for Agilent 82357A/B usb adapters"); 23 24 #define MAX_NUM_82357A_INTERFACES 128 25 static struct usb_interface *agilent_82357a_driver_interfaces[MAX_NUM_82357A_INTERFACES]; 26 static DEFINE_MUTEX(agilent_82357a_hotplug_lock); // protect board insertion and removal 27 28 static unsigned int agilent_82357a_update_status(struct gpib_board *board, 29 unsigned int clear_mask); 30 31 static int agilent_82357a_take_control_internal(struct gpib_board *board, int synchronous); 32 33 static void agilent_82357a_bulk_complete(struct urb *urb) 34 { 35 struct agilent_82357a_urb_ctx *context = urb->context; 36 37 complete(&context->complete); 38 } 39 40 static void agilent_82357a_timeout_handler(struct timer_list *t) 41 { 42 struct agilent_82357a_priv *a_priv = timer_container_of(a_priv, t, 43 bulk_timer); 44 struct agilent_82357a_urb_ctx *context = &a_priv->context; 45 46 context->timed_out = 1; 47 complete(&context->complete); 48 } 49 50 static int agilent_82357a_send_bulk_msg(struct agilent_82357a_priv *a_priv, void *data, 51 int data_length, int *actual_data_length, 52 int timeout_msecs) 53 { 54 struct usb_device *usb_dev; 55 int retval; 56 unsigned int out_pipe; 57 struct agilent_82357a_urb_ctx *context = &a_priv->context; 58 59 *actual_data_length = 0; 60 retval = mutex_lock_interruptible(&a_priv->bulk_alloc_lock); 61 if (retval) 62 return retval; 63 if (!a_priv->bus_interface) { 64 mutex_unlock(&a_priv->bulk_alloc_lock); 65 return -ENODEV; 66 } 67 if (a_priv->bulk_urb) { 68 mutex_unlock(&a_priv->bulk_alloc_lock); 69 return -EAGAIN; 70 } 71 a_priv->bulk_urb = usb_alloc_urb(0, GFP_KERNEL); 72 if (!a_priv->bulk_urb) { 73 mutex_unlock(&a_priv->bulk_alloc_lock); 74 return -ENOMEM; 75 } 76 usb_dev = interface_to_usbdev(a_priv->bus_interface); 77 out_pipe = usb_sndbulkpipe(usb_dev, a_priv->bulk_out_endpoint); 78 init_completion(&context->complete); 79 context->timed_out = 0; 80 usb_fill_bulk_urb(a_priv->bulk_urb, usb_dev, out_pipe, data, data_length, 81 &agilent_82357a_bulk_complete, context); 82 83 if (timeout_msecs) 84 mod_timer(&a_priv->bulk_timer, jiffies + msecs_to_jiffies(timeout_msecs)); 85 86 retval = usb_submit_urb(a_priv->bulk_urb, GFP_KERNEL); 87 if (retval) { 88 dev_err(&usb_dev->dev, "failed to submit bulk out urb, retval=%i\n", retval); 89 mutex_unlock(&a_priv->bulk_alloc_lock); 90 goto cleanup; 91 } 92 mutex_unlock(&a_priv->bulk_alloc_lock); 93 if (wait_for_completion_interruptible(&context->complete)) { 94 retval = -ERESTARTSYS; 95 goto cleanup; 96 } 97 if (context->timed_out) { 98 retval = -ETIMEDOUT; 99 } else { 100 retval = a_priv->bulk_urb->status; 101 *actual_data_length = a_priv->bulk_urb->actual_length; 102 } 103 cleanup: 104 if (timeout_msecs) { 105 if (timer_pending(&a_priv->bulk_timer)) 106 timer_delete_sync(&a_priv->bulk_timer); 107 } 108 mutex_lock(&a_priv->bulk_alloc_lock); 109 if (a_priv->bulk_urb) { 110 usb_kill_urb(a_priv->bulk_urb); 111 usb_free_urb(a_priv->bulk_urb); 112 a_priv->bulk_urb = NULL; 113 } 114 mutex_unlock(&a_priv->bulk_alloc_lock); 115 return retval; 116 } 117 118 static int agilent_82357a_receive_bulk_msg(struct agilent_82357a_priv *a_priv, void *data, 119 int data_length, int *actual_data_length, 120 int timeout_msecs) 121 { 122 struct usb_device *usb_dev; 123 int retval; 124 unsigned int in_pipe; 125 struct agilent_82357a_urb_ctx *context = &a_priv->context; 126 127 *actual_data_length = 0; 128 retval = mutex_lock_interruptible(&a_priv->bulk_alloc_lock); 129 if (retval) 130 return retval; 131 if (!a_priv->bus_interface) { 132 mutex_unlock(&a_priv->bulk_alloc_lock); 133 return -ENODEV; 134 } 135 if (a_priv->bulk_urb) { 136 mutex_unlock(&a_priv->bulk_alloc_lock); 137 return -EAGAIN; 138 } 139 a_priv->bulk_urb = usb_alloc_urb(0, GFP_KERNEL); 140 if (!a_priv->bulk_urb) { 141 mutex_unlock(&a_priv->bulk_alloc_lock); 142 return -ENOMEM; 143 } 144 usb_dev = interface_to_usbdev(a_priv->bus_interface); 145 in_pipe = usb_rcvbulkpipe(usb_dev, AGILENT_82357_BULK_IN_ENDPOINT); 146 init_completion(&context->complete); 147 context->timed_out = 0; 148 usb_fill_bulk_urb(a_priv->bulk_urb, usb_dev, in_pipe, data, data_length, 149 &agilent_82357a_bulk_complete, context); 150 151 if (timeout_msecs) 152 mod_timer(&a_priv->bulk_timer, jiffies + msecs_to_jiffies(timeout_msecs)); 153 154 retval = usb_submit_urb(a_priv->bulk_urb, GFP_KERNEL); 155 if (retval) { 156 dev_err(&usb_dev->dev, "failed to submit bulk in urb, retval=%i\n", retval); 157 mutex_unlock(&a_priv->bulk_alloc_lock); 158 goto cleanup; 159 } 160 mutex_unlock(&a_priv->bulk_alloc_lock); 161 if (wait_for_completion_interruptible(&context->complete)) { 162 retval = -ERESTARTSYS; 163 goto cleanup; 164 } 165 if (context->timed_out) { 166 retval = -ETIMEDOUT; 167 goto cleanup; 168 } 169 retval = a_priv->bulk_urb->status; 170 *actual_data_length = a_priv->bulk_urb->actual_length; 171 cleanup: 172 if (timeout_msecs) 173 timer_delete_sync(&a_priv->bulk_timer); 174 175 mutex_lock(&a_priv->bulk_alloc_lock); 176 if (a_priv->bulk_urb) { 177 usb_kill_urb(a_priv->bulk_urb); 178 usb_free_urb(a_priv->bulk_urb); 179 a_priv->bulk_urb = NULL; 180 } 181 mutex_unlock(&a_priv->bulk_alloc_lock); 182 return retval; 183 } 184 185 static int agilent_82357a_receive_control_msg(struct agilent_82357a_priv *a_priv, __u8 request, 186 __u8 requesttype, __u16 value, __u16 index, 187 void *data, __u16 size, int timeout_msecs) 188 { 189 struct usb_device *usb_dev; 190 int retval; 191 unsigned int in_pipe; 192 193 retval = mutex_lock_interruptible(&a_priv->control_alloc_lock); 194 if (retval) 195 return retval; 196 if (!a_priv->bus_interface) { 197 mutex_unlock(&a_priv->control_alloc_lock); 198 return -ENODEV; 199 } 200 usb_dev = interface_to_usbdev(a_priv->bus_interface); 201 in_pipe = usb_rcvctrlpipe(usb_dev, AGILENT_82357_CONTROL_ENDPOINT); 202 retval = usb_control_msg(usb_dev, in_pipe, request, requesttype, value, index, data, 203 size, timeout_msecs); 204 mutex_unlock(&a_priv->control_alloc_lock); 205 return retval; 206 } 207 208 static void agilent_82357a_dump_raw_block(const u8 *raw_data, int length) 209 { 210 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 8, 1, raw_data, length, true); 211 } 212 213 static int agilent_82357a_write_registers(struct agilent_82357a_priv *a_priv, 214 const struct agilent_82357a_register_pairlet *writes, 215 int num_writes) 216 { 217 struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface); 218 int retval; 219 u8 *out_data, *in_data; 220 int out_data_length, in_data_length; 221 int bytes_written, bytes_read; 222 int i = 0; 223 int j; 224 static const int bytes_per_write = 2; 225 static const int header_length = 2; 226 static const int max_writes = 31; 227 228 if (num_writes > max_writes) { 229 dev_err(&usb_dev->dev, "bug! num_writes=%i too large\n", num_writes); 230 return -EIO; 231 } 232 out_data_length = num_writes * bytes_per_write + header_length; 233 out_data = kmalloc(out_data_length, GFP_KERNEL); 234 if (!out_data) 235 return -ENOMEM; 236 237 out_data[i++] = DATA_PIPE_CMD_WR_REGS; 238 out_data[i++] = num_writes; 239 for (j = 0; j < num_writes; j++) { 240 out_data[i++] = writes[j].address; 241 out_data[i++] = writes[j].value; 242 } 243 244 retval = mutex_lock_interruptible(&a_priv->bulk_transfer_lock); 245 if (retval) { 246 kfree(out_data); 247 return retval; 248 } 249 retval = agilent_82357a_send_bulk_msg(a_priv, out_data, i, &bytes_written, 1000); 250 kfree(out_data); 251 if (retval) { 252 dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n", 253 retval, bytes_written, i); 254 mutex_unlock(&a_priv->bulk_transfer_lock); 255 return retval; 256 } 257 in_data_length = 0x20; 258 in_data = kmalloc(in_data_length, GFP_KERNEL); 259 if (!in_data) { 260 mutex_unlock(&a_priv->bulk_transfer_lock); 261 return -ENOMEM; 262 } 263 retval = agilent_82357a_receive_bulk_msg(a_priv, in_data, in_data_length, 264 &bytes_read, 1000); 265 mutex_unlock(&a_priv->bulk_transfer_lock); 266 267 if (retval) { 268 dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n", 269 retval, bytes_read); 270 agilent_82357a_dump_raw_block(in_data, bytes_read); 271 kfree(in_data); 272 return -EIO; 273 } 274 if (in_data[0] != (0xff & ~DATA_PIPE_CMD_WR_REGS)) { 275 dev_err(&usb_dev->dev, "bulk command=0x%x != ~DATA_PIPE_CMD_WR_REGS\n", in_data[0]); 276 return -EIO; 277 } 278 if (in_data[1]) { 279 dev_err(&usb_dev->dev, "nonzero error code 0x%x in DATA_PIPE_CMD_WR_REGS response\n", 280 in_data[1]); 281 return -EIO; 282 } 283 kfree(in_data); 284 return 0; 285 } 286 287 static int agilent_82357a_read_registers(struct agilent_82357a_priv *a_priv, 288 struct agilent_82357a_register_pairlet *reads, 289 int num_reads, int blocking) 290 { 291 struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface); 292 int retval; 293 u8 *out_data, *in_data; 294 int out_data_length, in_data_length; 295 int bytes_written, bytes_read; 296 int i = 0; 297 int j; 298 static const int header_length = 2; 299 static const int max_reads = 62; 300 301 if (num_reads > max_reads) { 302 dev_err(&usb_dev->dev, "bug! num_reads=%i too large\n", num_reads); 303 return -EIO; 304 } 305 out_data_length = num_reads + header_length; 306 out_data = kmalloc(out_data_length, GFP_KERNEL); 307 if (!out_data) 308 return -ENOMEM; 309 310 out_data[i++] = DATA_PIPE_CMD_RD_REGS; 311 out_data[i++] = num_reads; 312 for (j = 0; j < num_reads; j++) 313 out_data[i++] = reads[j].address; 314 315 if (blocking) { 316 retval = mutex_lock_interruptible(&a_priv->bulk_transfer_lock); 317 if (retval) { 318 kfree(out_data); 319 return retval; 320 } 321 } else { 322 retval = mutex_trylock(&a_priv->bulk_transfer_lock); 323 if (retval == 0) { 324 kfree(out_data); 325 return -EAGAIN; 326 } 327 } 328 retval = agilent_82357a_send_bulk_msg(a_priv, out_data, i, &bytes_written, 1000); 329 kfree(out_data); 330 if (retval) { 331 dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n", 332 retval, bytes_written, i); 333 mutex_unlock(&a_priv->bulk_transfer_lock); 334 return retval; 335 } 336 in_data_length = 0x20; 337 in_data = kmalloc(in_data_length, GFP_KERNEL); 338 if (!in_data) { 339 mutex_unlock(&a_priv->bulk_transfer_lock); 340 return -ENOMEM; 341 } 342 retval = agilent_82357a_receive_bulk_msg(a_priv, in_data, in_data_length, 343 &bytes_read, 10000); 344 mutex_unlock(&a_priv->bulk_transfer_lock); 345 346 if (retval) { 347 dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n", 348 retval, bytes_read); 349 agilent_82357a_dump_raw_block(in_data, bytes_read); 350 kfree(in_data); 351 return -EIO; 352 } 353 i = 0; 354 if (in_data[i++] != (0xff & ~DATA_PIPE_CMD_RD_REGS)) { 355 dev_err(&usb_dev->dev, "bulk command=0x%x != ~DATA_PIPE_CMD_RD_REGS\n", in_data[0]); 356 return -EIO; 357 } 358 if (in_data[i++]) { 359 dev_err(&usb_dev->dev, "nonzero error code 0x%x in DATA_PIPE_CMD_RD_REGS response\n", 360 in_data[1]); 361 return -EIO; 362 } 363 for (j = 0; j < num_reads; j++) 364 reads[j].value = in_data[i++]; 365 kfree(in_data); 366 return 0; 367 } 368 369 static int agilent_82357a_abort(struct agilent_82357a_priv *a_priv, int flush) 370 { 371 struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface); 372 int retval = 0; 373 int receive_control_retval; 374 u16 wIndex = 0; 375 u8 *status_data; 376 static const unsigned int status_data_len = 2; 377 378 status_data = kmalloc(status_data_len, GFP_KERNEL); 379 if (!status_data) 380 return -ENOMEM; 381 382 if (flush) 383 wIndex |= XA_FLUSH; 384 receive_control_retval = agilent_82357a_receive_control_msg(a_priv, 385 agilent_82357a_control_request, 386 USB_DIR_IN | USB_TYPE_VENDOR | 387 USB_RECIP_DEVICE, XFER_ABORT, 388 wIndex, status_data, 389 status_data_len, 100); 390 if (receive_control_retval < 0) { 391 dev_err(&usb_dev->dev, "82357a_receive_control_msg() returned %i\n", 392 receive_control_retval); 393 retval = -EIO; 394 goto cleanup; 395 } 396 if (status_data[0] != (~XFER_ABORT & 0xff)) { 397 dev_err(&usb_dev->dev, "major code=0x%x != ~XFER_ABORT\n", status_data[0]); 398 retval = -EIO; 399 goto cleanup; 400 } 401 switch (status_data[1]) { 402 case UGP_SUCCESS: 403 retval = 0; 404 break; 405 case UGP_ERR_FLUSHING: 406 if (flush) { 407 retval = 0; 408 break; 409 } 410 fallthrough; 411 case UGP_ERR_FLUSHING_ALREADY: 412 default: 413 dev_err(&usb_dev->dev, "abort returned error code=0x%x\n", status_data[1]); 414 retval = -EIO; 415 break; 416 } 417 418 cleanup: 419 kfree(status_data); 420 return retval; 421 } 422 423 // interface functions 424 int agilent_82357a_command(struct gpib_board *board, u8 *buffer, size_t length, 425 size_t *bytes_written); 426 427 static int agilent_82357a_read(struct gpib_board *board, u8 *buffer, size_t length, int *end, 428 size_t *nbytes) 429 { 430 int retval; 431 struct agilent_82357a_priv *a_priv = board->private_data; 432 struct usb_device *usb_dev; 433 u8 *out_data, *in_data; 434 int out_data_length, in_data_length; 435 int bytes_written, bytes_read; 436 int i = 0; 437 u8 trailing_flags; 438 unsigned long start_jiffies = jiffies; 439 int msec_timeout; 440 441 *nbytes = 0; 442 *end = 0; 443 444 if (!a_priv->bus_interface) 445 return -ENODEV; 446 usb_dev = interface_to_usbdev(a_priv->bus_interface); 447 out_data_length = 0x9; 448 out_data = kmalloc(out_data_length, GFP_KERNEL); 449 if (!out_data) 450 return -ENOMEM; 451 out_data[i++] = DATA_PIPE_CMD_READ; 452 out_data[i++] = 0; // primary address when ARF_NO_ADDR is not set 453 out_data[i++] = 0; // secondary address when ARF_NO_ADDR is not set 454 out_data[i] = ARF_NO_ADDRESS | ARF_END_ON_EOI; 455 if (a_priv->eos_mode & REOS) 456 out_data[i] |= ARF_END_ON_EOS_CHAR; 457 ++i; 458 out_data[i++] = length & 0xff; 459 out_data[i++] = (length >> 8) & 0xff; 460 out_data[i++] = (length >> 16) & 0xff; 461 out_data[i++] = (length >> 24) & 0xff; 462 out_data[i++] = a_priv->eos_char; 463 msec_timeout = (board->usec_timeout + 999) / 1000; 464 retval = mutex_lock_interruptible(&a_priv->bulk_transfer_lock); 465 if (retval) { 466 kfree(out_data); 467 return retval; 468 } 469 retval = agilent_82357a_send_bulk_msg(a_priv, out_data, i, &bytes_written, msec_timeout); 470 kfree(out_data); 471 if (retval || bytes_written != i) { 472 dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n", 473 retval, bytes_written, i); 474 mutex_unlock(&a_priv->bulk_transfer_lock); 475 if (retval < 0) 476 return retval; 477 return -EIO; 478 } 479 in_data_length = length + 1; 480 in_data = kmalloc(in_data_length, GFP_KERNEL); 481 if (!in_data) { 482 mutex_unlock(&a_priv->bulk_transfer_lock); 483 return -ENOMEM; 484 } 485 if (board->usec_timeout != 0) 486 msec_timeout -= jiffies_to_msecs(jiffies - start_jiffies) - 1; 487 if (msec_timeout >= 0) { 488 retval = agilent_82357a_receive_bulk_msg(a_priv, in_data, in_data_length, 489 &bytes_read, msec_timeout); 490 } else { 491 retval = -ETIMEDOUT; 492 bytes_read = 0; 493 } 494 if (retval == -ETIMEDOUT) { 495 int extra_bytes_read; 496 int extra_bytes_retval; 497 498 agilent_82357a_abort(a_priv, 1); 499 extra_bytes_retval = agilent_82357a_receive_bulk_msg(a_priv, in_data + bytes_read, 500 in_data_length - bytes_read, 501 &extra_bytes_read, 100); 502 bytes_read += extra_bytes_read; 503 if (extra_bytes_retval) { 504 dev_err(&usb_dev->dev, "extra_bytes_retval=%i, bytes_read=%i\n", 505 extra_bytes_retval, bytes_read); 506 agilent_82357a_abort(a_priv, 0); 507 } 508 } else if (retval) { 509 dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n", 510 retval, bytes_read); 511 agilent_82357a_abort(a_priv, 0); 512 } 513 mutex_unlock(&a_priv->bulk_transfer_lock); 514 if (bytes_read > length + 1) { 515 bytes_read = length + 1; 516 dev_warn(&usb_dev->dev, "bytes_read > length? truncating"); 517 } 518 519 if (bytes_read >= 1) { 520 memcpy(buffer, in_data, bytes_read - 1); 521 trailing_flags = in_data[bytes_read - 1]; 522 *nbytes = bytes_read - 1; 523 if (trailing_flags & (ATRF_EOI | ATRF_EOS)) 524 *end = 1; 525 } 526 kfree(in_data); 527 528 /* 529 * Fix for a bug in 9914A that does not return the contents of ADSR 530 * when the board is in listener active state and ATN is not asserted. 531 * Set ATN here to obtain a valid board level ibsta 532 */ 533 agilent_82357a_take_control_internal(board, 0); 534 535 // FIXME check trailing flags for error 536 return retval; 537 } 538 539 static ssize_t agilent_82357a_generic_write(struct gpib_board *board, 540 u8 *buffer, size_t length, 541 int send_commands, int send_eoi, 542 size_t *bytes_written) 543 { 544 int retval; 545 struct agilent_82357a_priv *a_priv = board->private_data; 546 struct usb_device *usb_dev; 547 u8 *out_data = NULL; 548 u8 *status_data = NULL; 549 int out_data_length; 550 int raw_bytes_written; 551 int i = 0, j; 552 int msec_timeout; 553 unsigned short bsr, adsr; 554 struct agilent_82357a_register_pairlet read_reg; 555 556 *bytes_written = 0; 557 if (!a_priv->bus_interface) 558 return -ENODEV; 559 560 usb_dev = interface_to_usbdev(a_priv->bus_interface); 561 out_data_length = length + 0x8; 562 out_data = kmalloc(out_data_length, GFP_KERNEL); 563 if (!out_data) 564 return -ENOMEM; 565 out_data[i++] = DATA_PIPE_CMD_WRITE; 566 out_data[i++] = 0; // primary address when AWF_NO_ADDRESS is not set 567 out_data[i++] = 0; // secondary address when AWF_NO_ADDRESS is not set 568 out_data[i] = AWF_NO_ADDRESS | AWF_NO_FAST_TALKER_FIRST_BYTE; 569 if (send_commands) 570 out_data[i] |= AWF_ATN | AWF_NO_FAST_TALKER; 571 if (send_eoi) 572 out_data[i] |= AWF_SEND_EOI; 573 ++i; 574 out_data[i++] = length & 0xff; 575 out_data[i++] = (length >> 8) & 0xff; 576 out_data[i++] = (length >> 16) & 0xff; 577 out_data[i++] = (length >> 24) & 0xff; 578 for (j = 0; j < length; j++) 579 out_data[i++] = buffer[j]; 580 581 clear_bit(AIF_WRITE_COMPLETE_BN, &a_priv->interrupt_flags); 582 583 msec_timeout = (board->usec_timeout + 999) / 1000; 584 retval = mutex_lock_interruptible(&a_priv->bulk_transfer_lock); 585 if (retval) { 586 kfree(out_data); 587 return retval; 588 } 589 retval = agilent_82357a_send_bulk_msg(a_priv, out_data, i, &raw_bytes_written, 590 msec_timeout); 591 kfree(out_data); 592 if (retval || raw_bytes_written != i) { 593 agilent_82357a_abort(a_priv, 0); 594 dev_err(&usb_dev->dev, "send_bulk_msg returned %i, raw_bytes_written=%i, i=%i\n", 595 retval, raw_bytes_written, i); 596 mutex_unlock(&a_priv->bulk_transfer_lock); 597 if (retval < 0) 598 return retval; 599 return -EIO; 600 } 601 602 retval = wait_event_interruptible(board->wait, 603 test_bit(AIF_WRITE_COMPLETE_BN, 604 &a_priv->interrupt_flags) || 605 test_bit(TIMO_NUM, &board->status)); 606 if (retval) { 607 dev_dbg(&usb_dev->dev, "wait write complete interrupted\n"); 608 agilent_82357a_abort(a_priv, 0); 609 mutex_unlock(&a_priv->bulk_transfer_lock); 610 return -ERESTARTSYS; 611 } 612 613 if (test_bit(AIF_WRITE_COMPLETE_BN, &a_priv->interrupt_flags) == 0) { 614 dev_dbg(&usb_dev->dev, "write timed out ibs %i, tmo %i\n", 615 test_bit(TIMO_NUM, &board->status), msec_timeout); 616 617 agilent_82357a_abort(a_priv, 0); 618 619 mutex_unlock(&a_priv->bulk_transfer_lock); 620 621 read_reg.address = BSR; 622 retval = agilent_82357a_read_registers(a_priv, &read_reg, 1, 1); 623 if (retval) { 624 dev_err(&usb_dev->dev, "read_registers() returned error\n"); 625 return -ETIMEDOUT; 626 } 627 628 bsr = read_reg.value; 629 dev_dbg(&usb_dev->dev, "write aborted bsr 0x%x\n", bsr); 630 631 if (send_commands) {/* check for no listeners */ 632 if ((bsr & BSR_ATN_BIT) && !(bsr & (BSR_NDAC_BIT | BSR_NRFD_BIT))) { 633 dev_dbg(&usb_dev->dev, "No listener on command\n"); 634 clear_bit(TIMO_NUM, &board->status); 635 return -ENOTCONN; // no listener on bus 636 } 637 } else { 638 read_reg.address = ADSR; 639 retval = agilent_82357a_read_registers(a_priv, &read_reg, 1, 1); 640 if (retval) { 641 dev_err(&usb_dev->dev, "read_registers() returned error\n"); 642 return -ETIMEDOUT; 643 } 644 adsr = read_reg.value; 645 if ((adsr & HR_TA) && !(bsr & (BSR_NDAC_BIT | BSR_NRFD_BIT))) { 646 dev_dbg(&usb_dev->dev, "No listener on write\n"); 647 clear_bit(TIMO_NUM, &board->status); 648 return -ECOMM; 649 } 650 } 651 652 return -ETIMEDOUT; 653 } 654 655 status_data = kmalloc(STATUS_DATA_LEN, GFP_KERNEL); 656 if (!status_data) { 657 mutex_unlock(&a_priv->bulk_transfer_lock); 658 return -ENOMEM; 659 } 660 661 retval = agilent_82357a_receive_control_msg(a_priv, agilent_82357a_control_request, 662 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 663 XFER_STATUS, 0, status_data, STATUS_DATA_LEN, 664 100); 665 mutex_unlock(&a_priv->bulk_transfer_lock); 666 if (retval < 0) { 667 dev_err(&usb_dev->dev, "receive_control_msg() returned %i\n", retval); 668 kfree(status_data); 669 return -EIO; 670 } 671 *bytes_written = (u32)status_data[2]; 672 *bytes_written |= (u32)status_data[3] << 8; 673 *bytes_written |= (u32)status_data[4] << 16; 674 *bytes_written |= (u32)status_data[5] << 24; 675 676 kfree(status_data); 677 return 0; 678 } 679 680 static int agilent_82357a_write(struct gpib_board *board, u8 *buffer, 681 size_t length, int send_eoi, size_t *bytes_written) 682 { 683 return agilent_82357a_generic_write(board, buffer, length, 0, send_eoi, bytes_written); 684 } 685 686 int agilent_82357a_command(struct gpib_board *board, u8 *buffer, size_t length, 687 size_t *bytes_written) 688 { 689 return agilent_82357a_generic_write(board, buffer, length, 1, 0, bytes_written); 690 } 691 692 int agilent_82357a_take_control_internal(struct gpib_board *board, int synchronous) 693 { 694 struct agilent_82357a_priv *a_priv = board->private_data; 695 struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface); 696 struct agilent_82357a_register_pairlet write; 697 int retval; 698 699 write.address = AUXCR; 700 if (synchronous) 701 write.value = AUX_TCS; 702 else 703 write.value = AUX_TCA; 704 retval = agilent_82357a_write_registers(a_priv, &write, 1); 705 if (retval) 706 dev_err(&usb_dev->dev, "write_registers() returned error\n"); 707 708 return retval; 709 } 710 711 static int agilent_82357a_take_control(struct gpib_board *board, int synchronous) 712 { 713 struct agilent_82357a_priv *a_priv = board->private_data; 714 const int timeout = 10; 715 int i; 716 717 if (!a_priv->bus_interface) 718 return -ENODEV; 719 720 /* 721 * It looks like the 9914 does not handle tcs properly. 722 * See comment above tms9914_take_control_workaround() in 723 * drivers/gpib/tms9914/tms9914_aux.c 724 */ 725 if (synchronous) 726 return -ETIMEDOUT; 727 728 agilent_82357a_take_control_internal(board, synchronous); 729 // busy wait until ATN is asserted 730 for (i = 0; i < timeout; ++i) { 731 agilent_82357a_update_status(board, 0); 732 if (test_bit(ATN_NUM, &board->status)) 733 break; 734 udelay(1); 735 } 736 if (i == timeout) 737 return -ETIMEDOUT; 738 return 0; 739 } 740 741 static int agilent_82357a_go_to_standby(struct gpib_board *board) 742 { 743 struct agilent_82357a_priv *a_priv = board->private_data; 744 struct usb_device *usb_dev; 745 struct agilent_82357a_register_pairlet write; 746 int retval; 747 748 if (!a_priv->bus_interface) 749 return -ENODEV; 750 751 usb_dev = interface_to_usbdev(a_priv->bus_interface); 752 write.address = AUXCR; 753 write.value = AUX_GTS; 754 retval = agilent_82357a_write_registers(a_priv, &write, 1); 755 if (retval) 756 dev_err(&usb_dev->dev, "write_registers() returned error\n"); 757 return 0; 758 } 759 760 static int agilent_82357a_request_system_control(struct gpib_board *board, int request_control) 761 { 762 struct agilent_82357a_priv *a_priv = board->private_data; 763 struct usb_device *usb_dev; 764 struct agilent_82357a_register_pairlet writes[2]; 765 int retval; 766 int i = 0; 767 768 if (!a_priv->bus_interface) 769 return -ENODEV; 770 771 usb_dev = interface_to_usbdev(a_priv->bus_interface); 772 /* 82357B needs bit to be set in 9914 AUXCR register */ 773 writes[i].address = AUXCR; 774 if (request_control) { 775 writes[i].value = AUX_RQC; 776 a_priv->hw_control_bits |= SYSTEM_CONTROLLER; 777 } else { 778 return -EINVAL; 779 } 780 ++i; 781 writes[i].address = HW_CONTROL; 782 writes[i].value = a_priv->hw_control_bits; 783 ++i; 784 retval = agilent_82357a_write_registers(a_priv, writes, i); 785 if (retval) 786 dev_err(&usb_dev->dev, "write_registers() returned error\n"); 787 return retval; 788 } 789 790 static void agilent_82357a_interface_clear(struct gpib_board *board, int assert) 791 { 792 struct agilent_82357a_priv *a_priv = board->private_data; 793 struct usb_device *usb_dev; 794 struct agilent_82357a_register_pairlet write; 795 int retval; 796 797 if (!a_priv->bus_interface) 798 return; // -ENODEV; 799 800 usb_dev = interface_to_usbdev(a_priv->bus_interface); 801 write.address = AUXCR; 802 write.value = AUX_SIC; 803 if (assert) { 804 write.value |= AUX_CS; 805 a_priv->is_cic = 1; 806 } 807 retval = agilent_82357a_write_registers(a_priv, &write, 1); 808 if (retval) 809 dev_err(&usb_dev->dev, "write_registers() returned error\n"); 810 } 811 812 static void agilent_82357a_remote_enable(struct gpib_board *board, int enable) 813 { 814 struct agilent_82357a_priv *a_priv = board->private_data; 815 struct usb_device *usb_dev; 816 struct agilent_82357a_register_pairlet write; 817 int retval; 818 819 if (!a_priv->bus_interface) 820 return; //-ENODEV; 821 822 usb_dev = interface_to_usbdev(a_priv->bus_interface); 823 write.address = AUXCR; 824 write.value = AUX_SRE; 825 if (enable) 826 write.value |= AUX_CS; 827 retval = agilent_82357a_write_registers(a_priv, &write, 1); 828 if (retval) 829 dev_err(&usb_dev->dev, "write_registers() returned error\n"); 830 a_priv->ren_state = enable; 831 return;// 0; 832 } 833 834 static int agilent_82357a_enable_eos(struct gpib_board *board, u8 eos_byte, 835 int compare_8_bits) 836 { 837 struct agilent_82357a_priv *a_priv = board->private_data; 838 839 if (!a_priv->bus_interface) 840 return -ENODEV; 841 if (compare_8_bits == 0) 842 return -EOPNOTSUPP; 843 844 a_priv->eos_char = eos_byte; 845 a_priv->eos_mode = REOS | BIN; 846 return 0; 847 } 848 849 static void agilent_82357a_disable_eos(struct gpib_board *board) 850 { 851 struct agilent_82357a_priv *a_priv = board->private_data; 852 853 a_priv->eos_mode &= ~REOS; 854 } 855 856 static unsigned int agilent_82357a_update_status(struct gpib_board *board, 857 unsigned int clear_mask) 858 { 859 struct agilent_82357a_priv *a_priv = board->private_data; 860 struct usb_device *usb_dev; 861 struct agilent_82357a_register_pairlet address_status, bus_status; 862 int retval; 863 864 if (!a_priv->bus_interface) 865 return -ENODEV; 866 usb_dev = interface_to_usbdev(a_priv->bus_interface); 867 board->status &= ~clear_mask; 868 if (a_priv->is_cic) 869 set_bit(CIC_NUM, &board->status); 870 else 871 clear_bit(CIC_NUM, &board->status); 872 address_status.address = ADSR; 873 retval = agilent_82357a_read_registers(a_priv, &address_status, 1, 0); 874 if (retval) { 875 if (retval != -EAGAIN) 876 dev_err(&usb_dev->dev, "read_registers() returned error\n"); 877 return board->status; 878 } 879 // check for remote/local 880 if (address_status.value & HR_REM) 881 set_bit(REM_NUM, &board->status); 882 else 883 clear_bit(REM_NUM, &board->status); 884 // check for lockout 885 if (address_status.value & HR_LLO) 886 set_bit(LOK_NUM, &board->status); 887 else 888 clear_bit(LOK_NUM, &board->status); 889 // check for ATN 890 if (address_status.value & HR_ATN) 891 set_bit(ATN_NUM, &board->status); 892 else 893 clear_bit(ATN_NUM, &board->status); 894 // check for talker/listener addressed 895 if (address_status.value & HR_TA) 896 set_bit(TACS_NUM, &board->status); 897 else 898 clear_bit(TACS_NUM, &board->status); 899 if (address_status.value & HR_LA) 900 set_bit(LACS_NUM, &board->status); 901 else 902 clear_bit(LACS_NUM, &board->status); 903 904 bus_status.address = BSR; 905 retval = agilent_82357a_read_registers(a_priv, &bus_status, 1, 0); 906 if (retval) { 907 if (retval != -EAGAIN) 908 dev_err(&usb_dev->dev, "read_registers() returned error\n"); 909 return board->status; 910 } 911 if (bus_status.value & BSR_SRQ_BIT) 912 set_bit(SRQI_NUM, &board->status); 913 else 914 clear_bit(SRQI_NUM, &board->status); 915 916 return board->status; 917 } 918 919 static int agilent_82357a_primary_address(struct gpib_board *board, unsigned int address) 920 { 921 struct agilent_82357a_priv *a_priv = board->private_data; 922 struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface); 923 struct agilent_82357a_register_pairlet write; 924 int retval; 925 926 if (!a_priv->bus_interface) 927 return -ENODEV; 928 usb_dev = interface_to_usbdev(a_priv->bus_interface); 929 // put primary address in address0 930 write.address = ADR; 931 write.value = address & ADDRESS_MASK; 932 retval = agilent_82357a_write_registers(a_priv, &write, 1); 933 if (retval) { 934 dev_err(&usb_dev->dev, "write_registers() returned error\n"); 935 return retval; 936 } 937 return retval; 938 } 939 940 static int agilent_82357a_secondary_address(struct gpib_board *board, 941 unsigned int address, int enable) 942 { 943 if (enable) 944 return -EOPNOTSUPP; 945 return 0; 946 } 947 948 static int agilent_82357a_parallel_poll(struct gpib_board *board, u8 *result) 949 { 950 struct agilent_82357a_priv *a_priv = board->private_data; 951 struct usb_device *usb_dev; 952 struct agilent_82357a_register_pairlet writes[2]; 953 struct agilent_82357a_register_pairlet read; 954 int retval; 955 956 if (!a_priv->bus_interface) 957 return -ENODEV; 958 usb_dev = interface_to_usbdev(a_priv->bus_interface); 959 // execute parallel poll 960 writes[0].address = AUXCR; 961 writes[0].value = AUX_CS | AUX_RPP; 962 writes[1].address = HW_CONTROL; 963 writes[1].value = a_priv->hw_control_bits & ~NOT_PARALLEL_POLL; 964 retval = agilent_82357a_write_registers(a_priv, writes, 2); 965 if (retval) { 966 dev_err(&usb_dev->dev, "write_registers() returned error\n"); 967 return retval; 968 } 969 udelay(2); // silly, since usb write will take way longer 970 read.address = CPTR; 971 retval = agilent_82357a_read_registers(a_priv, &read, 1, 1); 972 if (retval) { 973 dev_err(&usb_dev->dev, "read_registers() returned error\n"); 974 return retval; 975 } 976 *result = read.value; 977 // clear parallel poll state 978 writes[0].address = HW_CONTROL; 979 writes[0].value = a_priv->hw_control_bits | NOT_PARALLEL_POLL; 980 writes[1].address = AUXCR; 981 writes[1].value = AUX_RPP; 982 retval = agilent_82357a_write_registers(a_priv, writes, 2); 983 if (retval) { 984 dev_err(&usb_dev->dev, "write_registers() returned error\n"); 985 return retval; 986 } 987 return 0; 988 } 989 990 static void agilent_82357a_parallel_poll_configure(struct gpib_board *board, u8 config) 991 { 992 // board can only be system controller 993 return;// 0; 994 } 995 996 static void agilent_82357a_parallel_poll_response(struct gpib_board *board, int ist) 997 { 998 // board can only be system controller 999 return;// 0; 1000 } 1001 1002 static void agilent_82357a_serial_poll_response(struct gpib_board *board, u8 status) 1003 { 1004 // board can only be system controller 1005 return;// 0; 1006 } 1007 1008 static u8 agilent_82357a_serial_poll_status(struct gpib_board *board) 1009 { 1010 // board can only be system controller 1011 return 0; 1012 } 1013 1014 static void agilent_82357a_return_to_local(struct gpib_board *board) 1015 { 1016 // board can only be system controller 1017 return;// 0; 1018 } 1019 1020 static int agilent_82357a_line_status(const struct gpib_board *board) 1021 { 1022 struct agilent_82357a_priv *a_priv = board->private_data; 1023 struct usb_device *usb_dev; 1024 struct agilent_82357a_register_pairlet bus_status; 1025 int retval; 1026 int status = VALID_ALL; 1027 1028 if (!a_priv->bus_interface) 1029 return -ENODEV; 1030 usb_dev = interface_to_usbdev(a_priv->bus_interface); 1031 bus_status.address = BSR; 1032 retval = agilent_82357a_read_registers(a_priv, &bus_status, 1, 0); 1033 if (retval) { 1034 if (retval != -EAGAIN) 1035 dev_err(&usb_dev->dev, "read_registers() returned error\n"); 1036 return retval; 1037 } 1038 if (bus_status.value & BSR_REN_BIT) 1039 status |= BUS_REN; 1040 if (bus_status.value & BSR_IFC_BIT) 1041 status |= BUS_IFC; 1042 if (bus_status.value & BSR_SRQ_BIT) 1043 status |= BUS_SRQ; 1044 if (bus_status.value & BSR_EOI_BIT) 1045 status |= BUS_EOI; 1046 if (bus_status.value & BSR_NRFD_BIT) 1047 status |= BUS_NRFD; 1048 if (bus_status.value & BSR_NDAC_BIT) 1049 status |= BUS_NDAC; 1050 if (bus_status.value & BSR_DAV_BIT) 1051 status |= BUS_DAV; 1052 if (bus_status.value & BSR_ATN_BIT) 1053 status |= BUS_ATN; 1054 return status; 1055 } 1056 1057 static unsigned short nanosec_to_fast_talker_bits(unsigned int *nanosec) 1058 { 1059 static const int nanosec_per_bit = 21; 1060 static const int max_value = 0x72; 1061 static const int min_value = 0x11; 1062 unsigned short bits; 1063 1064 bits = (*nanosec + nanosec_per_bit / 2) / nanosec_per_bit; 1065 if (bits < min_value) 1066 bits = min_value; 1067 if (bits > max_value) 1068 bits = max_value; 1069 *nanosec = bits * nanosec_per_bit; 1070 return bits; 1071 } 1072 1073 static int agilent_82357a_t1_delay(struct gpib_board *board, unsigned int nanosec) 1074 { 1075 struct agilent_82357a_priv *a_priv = board->private_data; 1076 struct usb_device *usb_dev; 1077 struct agilent_82357a_register_pairlet write; 1078 int retval; 1079 1080 if (!a_priv->bus_interface) 1081 return -ENODEV; 1082 usb_dev = interface_to_usbdev(a_priv->bus_interface); 1083 write.address = FAST_TALKER_T1; 1084 write.value = nanosec_to_fast_talker_bits(&nanosec); 1085 retval = agilent_82357a_write_registers(a_priv, &write, 1); 1086 if (retval) 1087 dev_err(&usb_dev->dev, "write_registers() returned error\n"); 1088 return nanosec; 1089 } 1090 1091 static void agilent_82357a_interrupt_complete(struct urb *urb) 1092 { 1093 struct gpib_board *board = urb->context; 1094 struct agilent_82357a_priv *a_priv = board->private_data; 1095 struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface); 1096 int retval; 1097 u8 *transfer_buffer = urb->transfer_buffer; 1098 unsigned long interrupt_flags; 1099 1100 switch (urb->status) { 1101 /* success */ 1102 case 0: 1103 break; 1104 /* unlinked, don't resubmit */ 1105 case -ECONNRESET: 1106 case -ENOENT: 1107 case -ESHUTDOWN: 1108 return; 1109 default: /* other error, resubmit */ 1110 retval = usb_submit_urb(a_priv->interrupt_urb, GFP_ATOMIC); 1111 if (retval) 1112 dev_err(&usb_dev->dev, "failed to resubmit interrupt urb\n"); 1113 return; 1114 } 1115 1116 interrupt_flags = transfer_buffer[0]; 1117 if (test_bit(AIF_READ_COMPLETE_BN, &interrupt_flags)) 1118 set_bit(AIF_READ_COMPLETE_BN, &a_priv->interrupt_flags); 1119 if (test_bit(AIF_WRITE_COMPLETE_BN, &interrupt_flags)) 1120 set_bit(AIF_WRITE_COMPLETE_BN, &a_priv->interrupt_flags); 1121 if (test_bit(AIF_SRQ_BN, &interrupt_flags)) 1122 set_bit(SRQI_NUM, &board->status); 1123 1124 wake_up_interruptible(&board->wait); 1125 1126 retval = usb_submit_urb(a_priv->interrupt_urb, GFP_ATOMIC); 1127 if (retval) 1128 dev_err(&usb_dev->dev, "failed to resubmit interrupt urb\n"); 1129 } 1130 1131 static int agilent_82357a_setup_urbs(struct gpib_board *board) 1132 { 1133 struct agilent_82357a_priv *a_priv = board->private_data; 1134 struct usb_device *usb_dev; 1135 int int_pipe; 1136 int retval; 1137 1138 retval = mutex_lock_interruptible(&a_priv->interrupt_alloc_lock); 1139 if (retval) 1140 return retval; 1141 if (!a_priv->bus_interface) { 1142 retval = -ENODEV; 1143 goto setup_exit; 1144 } 1145 1146 a_priv->interrupt_buffer = kmalloc(INTERRUPT_BUF_LEN, GFP_KERNEL); 1147 if (!a_priv->interrupt_buffer) { 1148 retval = -ENOMEM; 1149 goto setup_exit; 1150 } 1151 a_priv->interrupt_urb = usb_alloc_urb(0, GFP_KERNEL); 1152 if (!a_priv->interrupt_urb) { 1153 retval = -ENOMEM; 1154 goto setup_exit; 1155 } 1156 usb_dev = interface_to_usbdev(a_priv->bus_interface); 1157 int_pipe = usb_rcvintpipe(usb_dev, a_priv->interrupt_in_endpoint); 1158 usb_fill_int_urb(a_priv->interrupt_urb, usb_dev, int_pipe, a_priv->interrupt_buffer, 1159 INTERRUPT_BUF_LEN, &agilent_82357a_interrupt_complete, board, 1); 1160 retval = usb_submit_urb(a_priv->interrupt_urb, GFP_KERNEL); 1161 if (retval) { 1162 usb_free_urb(a_priv->interrupt_urb); 1163 a_priv->interrupt_urb = NULL; 1164 dev_err(&usb_dev->dev, "failed to submit first interrupt urb, retval=%i\n", retval); 1165 goto setup_exit; 1166 } 1167 mutex_unlock(&a_priv->interrupt_alloc_lock); 1168 return 0; 1169 1170 setup_exit: 1171 kfree(a_priv->interrupt_buffer); 1172 mutex_unlock(&a_priv->interrupt_alloc_lock); 1173 return retval; 1174 } 1175 1176 static void agilent_82357a_cleanup_urbs(struct agilent_82357a_priv *a_priv) 1177 { 1178 if (a_priv && a_priv->bus_interface) { 1179 if (a_priv->interrupt_urb) 1180 usb_kill_urb(a_priv->interrupt_urb); 1181 if (a_priv->bulk_urb) 1182 usb_kill_urb(a_priv->bulk_urb); 1183 } 1184 }; 1185 1186 static void agilent_82357a_release_urbs(struct agilent_82357a_priv *a_priv) 1187 { 1188 if (a_priv) { 1189 usb_free_urb(a_priv->interrupt_urb); 1190 a_priv->interrupt_urb = NULL; 1191 kfree(a_priv->interrupt_buffer); 1192 } 1193 } 1194 1195 static int agilent_82357a_allocate_private(struct gpib_board *board) 1196 { 1197 struct agilent_82357a_priv *a_priv; 1198 1199 board->private_data = kzalloc_obj(struct agilent_82357a_priv); 1200 if (!board->private_data) 1201 return -ENOMEM; 1202 a_priv = board->private_data; 1203 mutex_init(&a_priv->bulk_transfer_lock); 1204 mutex_init(&a_priv->bulk_alloc_lock); 1205 mutex_init(&a_priv->control_alloc_lock); 1206 mutex_init(&a_priv->interrupt_alloc_lock); 1207 return 0; 1208 } 1209 1210 static void agilent_82357a_free_private(struct gpib_board *board) 1211 { 1212 kfree(board->private_data); 1213 board->private_data = NULL; 1214 } 1215 1216 #define INIT_NUM_REG_WRITES 18 1217 static int agilent_82357a_init(struct gpib_board *board) 1218 { 1219 struct agilent_82357a_priv *a_priv = board->private_data; 1220 struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface); 1221 struct agilent_82357a_register_pairlet hw_control; 1222 struct agilent_82357a_register_pairlet writes[INIT_NUM_REG_WRITES]; 1223 int retval; 1224 unsigned int nanosec; 1225 1226 writes[0].address = LED_CONTROL; 1227 writes[0].value = FAIL_LED_ON; 1228 writes[1].address = RESET_TO_POWERUP; 1229 writes[1].value = RESET_SPACEBALL; 1230 retval = agilent_82357a_write_registers(a_priv, writes, 2); 1231 if (retval) { 1232 dev_err(&usb_dev->dev, "write_registers() returned error\n"); 1233 return -EIO; 1234 } 1235 set_current_state(TASK_INTERRUPTIBLE); 1236 if (schedule_timeout(usec_to_jiffies(2000))) 1237 return -ERESTARTSYS; 1238 writes[0].address = AUXCR; 1239 writes[0].value = AUX_NBAF; 1240 writes[1].address = AUXCR; 1241 writes[1].value = AUX_HLDE; 1242 writes[2].address = AUXCR; 1243 writes[2].value = AUX_TON; 1244 writes[3].address = AUXCR; 1245 writes[3].value = AUX_LON; 1246 writes[4].address = AUXCR; 1247 writes[4].value = AUX_RSV2; 1248 writes[5].address = AUXCR; 1249 writes[5].value = AUX_INVAL; 1250 writes[6].address = AUXCR; 1251 writes[6].value = AUX_RPP; 1252 writes[7].address = AUXCR; 1253 writes[7].value = AUX_STDL; 1254 writes[8].address = AUXCR; 1255 writes[8].value = AUX_VSTDL; 1256 writes[9].address = FAST_TALKER_T1; 1257 nanosec = board->t1_nano_sec; 1258 writes[9].value = nanosec_to_fast_talker_bits(&nanosec); 1259 board->t1_nano_sec = nanosec; 1260 writes[10].address = ADR; 1261 writes[10].value = board->pad & ADDRESS_MASK; 1262 writes[11].address = PPR; 1263 writes[11].value = 0; 1264 writes[12].address = SPMR; 1265 writes[12].value = 0; 1266 writes[13].address = PROTOCOL_CONTROL; 1267 writes[13].value = WRITE_COMPLETE_INTERRUPT_EN; 1268 writes[14].address = IMR0; 1269 writes[14].value = HR_BOIE | HR_BIIE; 1270 writes[15].address = IMR1; 1271 writes[15].value = HR_SRQIE; 1272 // turn off reset state 1273 writes[16].address = AUXCR; 1274 writes[16].value = AUX_CHIP_RESET; 1275 writes[17].address = LED_CONTROL; 1276 writes[17].value = FIRMWARE_LED_CONTROL; 1277 retval = agilent_82357a_write_registers(a_priv, writes, INIT_NUM_REG_WRITES); 1278 if (retval) { 1279 dev_err(&usb_dev->dev, "write_registers() returned error\n"); 1280 return -EIO; 1281 } 1282 hw_control.address = HW_CONTROL; 1283 retval = agilent_82357a_read_registers(a_priv, &hw_control, 1, 1); 1284 if (retval) { 1285 dev_err(&usb_dev->dev, "read_registers() returned error\n"); 1286 return -EIO; 1287 } 1288 a_priv->hw_control_bits = (hw_control.value & ~0x7) | NOT_TI_RESET | NOT_PARALLEL_POLL; 1289 1290 return 0; 1291 } 1292 1293 static inline int agilent_82357a_device_match(struct usb_interface *interface, 1294 const struct gpib_board_config *config) 1295 { 1296 struct usb_device * const usbdev = interface_to_usbdev(interface); 1297 1298 if (gpib_match_device_path(&interface->dev, config->device_path) == 0) 1299 return 0; 1300 if (config->serial_number && 1301 (!usbdev->serial || strcmp(usbdev->serial, config->serial_number) != 0)) 1302 return 0; 1303 1304 return 1; 1305 } 1306 1307 static int agilent_82357a_attach(struct gpib_board *board, const struct gpib_board_config *config) 1308 { 1309 int retval; 1310 int i; 1311 unsigned int product_id; 1312 struct agilent_82357a_priv *a_priv; 1313 struct usb_device *usb_dev; 1314 1315 if (mutex_lock_interruptible(&agilent_82357a_hotplug_lock)) 1316 return -ERESTARTSYS; 1317 1318 retval = agilent_82357a_allocate_private(board); 1319 if (retval) { 1320 mutex_unlock(&agilent_82357a_hotplug_lock); 1321 return retval; 1322 } 1323 a_priv = board->private_data; 1324 for (i = 0; i < MAX_NUM_82357A_INTERFACES; ++i) { 1325 if (agilent_82357a_driver_interfaces[i] && 1326 !usb_get_intfdata(agilent_82357a_driver_interfaces[i]) && 1327 agilent_82357a_device_match(agilent_82357a_driver_interfaces[i], config)) { 1328 a_priv->bus_interface = agilent_82357a_driver_interfaces[i]; 1329 usb_set_intfdata(agilent_82357a_driver_interfaces[i], board); 1330 usb_dev = interface_to_usbdev(a_priv->bus_interface); 1331 break; 1332 } 1333 } 1334 if (i == MAX_NUM_82357A_INTERFACES) { 1335 dev_err(board->gpib_dev, 1336 "No supported adapters found, have you loaded its firmware?\n"); 1337 retval = -ENODEV; 1338 goto attach_fail; 1339 } 1340 product_id = le16_to_cpu(interface_to_usbdev(a_priv->bus_interface)->descriptor.idProduct); 1341 switch (product_id) { 1342 case USB_DEVICE_ID_AGILENT_82357A: 1343 a_priv->bulk_out_endpoint = AGILENT_82357A_BULK_OUT_ENDPOINT; 1344 a_priv->interrupt_in_endpoint = AGILENT_82357A_INTERRUPT_IN_ENDPOINT; 1345 break; 1346 case USB_DEVICE_ID_AGILENT_82357B: 1347 a_priv->bulk_out_endpoint = AGILENT_82357B_BULK_OUT_ENDPOINT; 1348 a_priv->interrupt_in_endpoint = AGILENT_82357B_INTERRUPT_IN_ENDPOINT; 1349 break; 1350 default: 1351 dev_err(&usb_dev->dev, "bug, unhandled product_id in switch?\n"); 1352 retval = -EIO; 1353 goto attach_fail; 1354 } 1355 1356 retval = agilent_82357a_setup_urbs(board); 1357 if (retval < 0) 1358 goto attach_fail; 1359 1360 timer_setup(&a_priv->bulk_timer, agilent_82357a_timeout_handler, 0); 1361 1362 board->t1_nano_sec = 800; 1363 1364 retval = agilent_82357a_init(board); 1365 1366 if (retval < 0) { 1367 agilent_82357a_cleanup_urbs(a_priv); 1368 agilent_82357a_release_urbs(a_priv); 1369 goto attach_fail; 1370 } 1371 1372 dev_info(&usb_dev->dev, "bus %d dev num %d attached to gpib%d, interface %i\n", 1373 usb_dev->bus->busnum, usb_dev->devnum, board->minor, i); 1374 mutex_unlock(&agilent_82357a_hotplug_lock); 1375 return retval; 1376 1377 attach_fail: 1378 agilent_82357a_free_private(board); 1379 mutex_unlock(&agilent_82357a_hotplug_lock); 1380 return retval; 1381 } 1382 1383 static int agilent_82357a_go_idle(struct gpib_board *board) 1384 { 1385 struct agilent_82357a_priv *a_priv = board->private_data; 1386 struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface); 1387 struct agilent_82357a_register_pairlet writes[0x20]; 1388 int retval; 1389 1390 // turn on tms9914 reset state 1391 writes[0].address = AUXCR; 1392 writes[0].value = AUX_CS | AUX_CHIP_RESET; 1393 a_priv->hw_control_bits &= ~NOT_TI_RESET; 1394 writes[1].address = HW_CONTROL; 1395 writes[1].value = a_priv->hw_control_bits; 1396 writes[2].address = PROTOCOL_CONTROL; 1397 writes[2].value = 0; 1398 writes[3].address = IMR0; 1399 writes[3].value = 0; 1400 writes[4].address = IMR1; 1401 writes[4].value = 0; 1402 writes[5].address = LED_CONTROL; 1403 writes[5].value = 0; 1404 retval = agilent_82357a_write_registers(a_priv, writes, 6); 1405 if (retval) { 1406 dev_err(&usb_dev->dev, "write_registers() returned error\n"); 1407 return -EIO; 1408 } 1409 return 0; 1410 } 1411 1412 static void agilent_82357a_detach(struct gpib_board *board) 1413 { 1414 struct agilent_82357a_priv *a_priv; 1415 1416 mutex_lock(&agilent_82357a_hotplug_lock); 1417 1418 a_priv = board->private_data; 1419 if (a_priv) { 1420 if (a_priv->bus_interface) { 1421 agilent_82357a_go_idle(board); 1422 usb_set_intfdata(a_priv->bus_interface, NULL); 1423 } 1424 mutex_lock(&a_priv->control_alloc_lock); 1425 mutex_lock(&a_priv->bulk_alloc_lock); 1426 mutex_lock(&a_priv->interrupt_alloc_lock); 1427 agilent_82357a_cleanup_urbs(a_priv); 1428 agilent_82357a_release_urbs(a_priv); 1429 agilent_82357a_free_private(board); 1430 } 1431 mutex_unlock(&agilent_82357a_hotplug_lock); 1432 } 1433 1434 static struct gpib_interface agilent_82357a_gpib_interface = { 1435 .name = "agilent_82357a", 1436 .attach = agilent_82357a_attach, 1437 .detach = agilent_82357a_detach, 1438 .read = agilent_82357a_read, 1439 .write = agilent_82357a_write, 1440 .command = agilent_82357a_command, 1441 .take_control = agilent_82357a_take_control, 1442 .go_to_standby = agilent_82357a_go_to_standby, 1443 .request_system_control = agilent_82357a_request_system_control, 1444 .interface_clear = agilent_82357a_interface_clear, 1445 .remote_enable = agilent_82357a_remote_enable, 1446 .enable_eos = agilent_82357a_enable_eos, 1447 .disable_eos = agilent_82357a_disable_eos, 1448 .parallel_poll = agilent_82357a_parallel_poll, 1449 .parallel_poll_configure = agilent_82357a_parallel_poll_configure, 1450 .parallel_poll_response = agilent_82357a_parallel_poll_response, 1451 .local_parallel_poll_mode = NULL, // XXX 1452 .line_status = agilent_82357a_line_status, 1453 .update_status = agilent_82357a_update_status, 1454 .primary_address = agilent_82357a_primary_address, 1455 .secondary_address = agilent_82357a_secondary_address, 1456 .serial_poll_response = agilent_82357a_serial_poll_response, 1457 .serial_poll_status = agilent_82357a_serial_poll_status, 1458 .t1_delay = agilent_82357a_t1_delay, 1459 .return_to_local = agilent_82357a_return_to_local, 1460 .no_7_bit_eos = 1, 1461 .skip_check_for_command_acceptors = 1 1462 }; 1463 1464 // Table with the USB-devices: just now only testing IDs 1465 static struct usb_device_id agilent_82357a_driver_device_table[] = { 1466 {USB_DEVICE(USB_VENDOR_ID_AGILENT, USB_DEVICE_ID_AGILENT_82357A)}, 1467 {USB_DEVICE(USB_VENDOR_ID_AGILENT, USB_DEVICE_ID_AGILENT_82357B)}, 1468 {} /* Terminating entry */ 1469 }; 1470 MODULE_DEVICE_TABLE(usb, agilent_82357a_driver_device_table); 1471 1472 static int agilent_82357a_driver_probe(struct usb_interface *interface, 1473 const struct usb_device_id *id) 1474 { 1475 int i; 1476 char *path; 1477 static const int path_length = 1024; 1478 struct usb_device *usb_dev; 1479 1480 if (mutex_lock_interruptible(&agilent_82357a_hotplug_lock)) 1481 return -ERESTARTSYS; 1482 usb_dev = interface_to_usbdev(interface); 1483 for (i = 0; i < MAX_NUM_82357A_INTERFACES; ++i) { 1484 if (!agilent_82357a_driver_interfaces[i]) { 1485 agilent_82357a_driver_interfaces[i] = interface; 1486 usb_set_intfdata(interface, NULL); 1487 dev_dbg(&usb_dev->dev, "set bus interface %i to address 0x%p\n", 1488 i, interface); 1489 break; 1490 } 1491 } 1492 if (i == MAX_NUM_82357A_INTERFACES) { 1493 mutex_unlock(&agilent_82357a_hotplug_lock); 1494 dev_err(&usb_dev->dev, "out of space in agilent_82357a_driver_interfaces[]\n"); 1495 return -1; 1496 } 1497 path = kmalloc(path_length, GFP_KERNEL); 1498 if (!path) { 1499 mutex_unlock(&agilent_82357a_hotplug_lock); 1500 return -ENOMEM; 1501 } 1502 usb_make_path(usb_dev, path, path_length); 1503 dev_info(&usb_dev->dev, "probe succeeded for path: %s\n", path); 1504 kfree(path); 1505 mutex_unlock(&agilent_82357a_hotplug_lock); 1506 return 0; 1507 } 1508 1509 static void agilent_82357a_driver_disconnect(struct usb_interface *interface) 1510 { 1511 int i; 1512 struct usb_device *usb_dev = interface_to_usbdev(interface); 1513 1514 mutex_lock(&agilent_82357a_hotplug_lock); 1515 1516 for (i = 0; i < MAX_NUM_82357A_INTERFACES; ++i) { 1517 if (agilent_82357a_driver_interfaces[i] == interface) { 1518 struct gpib_board *board = usb_get_intfdata(interface); 1519 1520 if (board) { 1521 struct agilent_82357a_priv *a_priv = board->private_data; 1522 1523 if (a_priv) { 1524 mutex_lock(&a_priv->control_alloc_lock); 1525 mutex_lock(&a_priv->bulk_alloc_lock); 1526 mutex_lock(&a_priv->interrupt_alloc_lock); 1527 agilent_82357a_cleanup_urbs(a_priv); 1528 a_priv->bus_interface = NULL; 1529 mutex_unlock(&a_priv->interrupt_alloc_lock); 1530 mutex_unlock(&a_priv->bulk_alloc_lock); 1531 mutex_unlock(&a_priv->control_alloc_lock); 1532 } 1533 } 1534 agilent_82357a_driver_interfaces[i] = NULL; 1535 break; 1536 } 1537 } 1538 if (i == MAX_NUM_82357A_INTERFACES) 1539 dev_err(&usb_dev->dev, "unable to find interface - bug?\n"); 1540 1541 mutex_unlock(&agilent_82357a_hotplug_lock); 1542 } 1543 1544 static int agilent_82357a_driver_suspend(struct usb_interface *interface, pm_message_t message) 1545 { 1546 int i, retval; 1547 struct usb_device *usb_dev = interface_to_usbdev(interface); 1548 1549 mutex_lock(&agilent_82357a_hotplug_lock); 1550 1551 for (i = 0; i < MAX_NUM_82357A_INTERFACES; ++i) { 1552 if (agilent_82357a_driver_interfaces[i] == interface) { 1553 struct gpib_board *board = usb_get_intfdata(interface); 1554 1555 if (board) { 1556 struct agilent_82357a_priv *a_priv = board->private_data; 1557 1558 if (a_priv) { 1559 agilent_82357a_abort(a_priv, 0); 1560 agilent_82357a_abort(a_priv, 0); 1561 retval = agilent_82357a_go_idle(board); 1562 if (retval) { 1563 dev_err(&usb_dev->dev, "failed to go idle, retval=%i\n", 1564 retval); 1565 mutex_unlock(&agilent_82357a_hotplug_lock); 1566 return retval; 1567 } 1568 mutex_lock(&a_priv->interrupt_alloc_lock); 1569 agilent_82357a_cleanup_urbs(a_priv); 1570 mutex_unlock(&a_priv->interrupt_alloc_lock); 1571 dev_dbg(&usb_dev->dev, 1572 "bus %d dev num %d gpib %d, interface %i suspended\n", 1573 usb_dev->bus->busnum, usb_dev->devnum, 1574 board->minor, i); 1575 } 1576 } 1577 break; 1578 } 1579 } 1580 1581 mutex_unlock(&agilent_82357a_hotplug_lock); 1582 1583 return 0; 1584 } 1585 1586 static int agilent_82357a_driver_resume(struct usb_interface *interface) 1587 { 1588 struct usb_device *usb_dev = interface_to_usbdev(interface); 1589 struct gpib_board *board; 1590 int i, retval = 0; 1591 1592 mutex_lock(&agilent_82357a_hotplug_lock); 1593 1594 for (i = 0; i < MAX_NUM_82357A_INTERFACES; ++i) { 1595 if (agilent_82357a_driver_interfaces[i] == interface) { 1596 board = usb_get_intfdata(interface); 1597 if (board) 1598 break; 1599 } 1600 } 1601 if (i == MAX_NUM_82357A_INTERFACES) { 1602 retval = -ENOENT; 1603 goto resume_exit; 1604 } 1605 1606 struct agilent_82357a_priv *a_priv = board->private_data; 1607 1608 if (a_priv) { 1609 if (a_priv->interrupt_urb) { 1610 mutex_lock(&a_priv->interrupt_alloc_lock); 1611 retval = usb_submit_urb(a_priv->interrupt_urb, GFP_KERNEL); 1612 if (retval) { 1613 dev_err(&usb_dev->dev, "failed to resubmit interrupt urb in resume, retval=%i\n", 1614 retval); 1615 mutex_unlock(&a_priv->interrupt_alloc_lock); 1616 mutex_unlock(&agilent_82357a_hotplug_lock); 1617 return retval; 1618 } 1619 mutex_unlock(&a_priv->interrupt_alloc_lock); 1620 } 1621 retval = agilent_82357a_init(board); 1622 if (retval < 0) { 1623 mutex_unlock(&agilent_82357a_hotplug_lock); 1624 return retval; 1625 } 1626 // set/unset system controller 1627 retval = agilent_82357a_request_system_control(board, board->master); 1628 // toggle ifc if master 1629 if (board->master) { 1630 agilent_82357a_interface_clear(board, 1); 1631 usleep_range(200, 250); 1632 agilent_82357a_interface_clear(board, 0); 1633 } 1634 // assert/unassert REN 1635 agilent_82357a_remote_enable(board, a_priv->ren_state); 1636 1637 dev_dbg(&usb_dev->dev, 1638 "bus %d dev num %d gpib%d, interface %i resumed\n", 1639 usb_dev->bus->busnum, usb_dev->devnum, board->minor, i); 1640 } 1641 1642 resume_exit: 1643 mutex_unlock(&agilent_82357a_hotplug_lock); 1644 1645 return retval; 1646 } 1647 1648 static struct usb_driver agilent_82357a_bus_driver = { 1649 .name = DRV_NAME, 1650 .probe = agilent_82357a_driver_probe, 1651 .disconnect = agilent_82357a_driver_disconnect, 1652 .suspend = agilent_82357a_driver_suspend, 1653 .resume = agilent_82357a_driver_resume, 1654 .id_table = agilent_82357a_driver_device_table, 1655 }; 1656 1657 static int __init agilent_82357a_init_module(void) 1658 { 1659 int i; 1660 int ret; 1661 1662 for (i = 0; i < MAX_NUM_82357A_INTERFACES; ++i) 1663 agilent_82357a_driver_interfaces[i] = NULL; 1664 1665 ret = usb_register(&agilent_82357a_bus_driver); 1666 if (ret) { 1667 pr_err("usb_register failed: error = %d\n", ret); 1668 return ret; 1669 } 1670 1671 ret = gpib_register_driver(&agilent_82357a_gpib_interface, THIS_MODULE); 1672 if (ret) { 1673 pr_err("gpib_register_driver failed: error = %d\n", ret); 1674 usb_deregister(&agilent_82357a_bus_driver); 1675 return ret; 1676 } 1677 1678 return 0; 1679 } 1680 1681 static void __exit agilent_82357a_exit_module(void) 1682 { 1683 gpib_unregister_driver(&agilent_82357a_gpib_interface); 1684 usb_deregister(&agilent_82357a_bus_driver); 1685 } 1686 1687 module_init(agilent_82357a_init_module); 1688 module_exit(agilent_82357a_exit_module); 1689