1 // SPDX-License-Identifier: GPL-2.0 2 3 /*************************************************************************** 4 * driver for National Instruments usb to gpib adapters 5 * copyright : (C) 2004 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 <linux/kernel.h> 13 #include <linux/module.h> 14 #include <linux/slab.h> 15 #include "ni_usb_gpib.h" 16 #include "gpibP.h" 17 #include "nec7210.h" 18 #include "tnt4882_registers.h" 19 20 MODULE_LICENSE("GPL"); 21 MODULE_DESCRIPTION("GPIB driver for National Instruments USB devices"); 22 23 #define MAX_NUM_NI_USB_INTERFACES 128 24 static struct usb_interface *ni_usb_driver_interfaces[MAX_NUM_NI_USB_INTERFACES]; 25 26 static int ni_usb_parse_status_block(const u8 *buffer, struct ni_usb_status_block *status); 27 static int ni_usb_set_interrupt_monitor(struct gpib_board *board, unsigned int monitored_bits); 28 static void ni_usb_stop(struct ni_usb_priv *ni_priv); 29 30 static DEFINE_MUTEX(ni_usb_hotplug_lock); 31 32 // calculates a reasonable timeout in that can be passed to usb functions 33 static inline unsigned long ni_usb_timeout_msecs(unsigned int usec) 34 { 35 if (usec == 0) 36 return 0; 37 return 2000 + usec / 500; 38 }; 39 40 // returns timeout code byte for use in ni-usb-b instructions 41 static unsigned short ni_usb_timeout_code(unsigned int usec) 42 { 43 if (usec == 0) 44 return 0xf0; 45 else if (usec <= 10) 46 return 0xf1; 47 else if (usec <= 30) 48 return 0xf2; 49 else if (usec <= 100) 50 return 0xf3; 51 else if (usec <= 300) 52 return 0xf4; 53 else if (usec <= 1000) 54 return 0xf5; 55 else if (usec <= 3000) 56 return 0xf6; 57 else if (usec <= 10000) 58 return 0xf7; 59 else if (usec <= 30000) 60 return 0xf8; 61 else if (usec <= 100000) 62 return 0xf9; 63 else if (usec <= 300000) 64 return 0xfa; 65 else if (usec <= 1000000) 66 return 0xfb; 67 else if (usec <= 3000000) 68 return 0xfc; 69 else if (usec <= 10000000) 70 return 0xfd; 71 else if (usec <= 30000000) 72 return 0xfe; 73 else if (usec <= 100000000) 74 return 0xff; 75 else if (usec <= 300000000) 76 return 0x01; 77 /* 78 * NI driver actually uses 0xff for timeout T1000s, which is a bug in their code. 79 * I've verified on a usb-b that a code of 0x2 is correct for a 1000 sec timeout 80 */ 81 else if (usec <= 1000000000) 82 return 0x02; 83 pr_err("bug? usec is greater than 1e9\n"); 84 return 0xf0; 85 } 86 87 static void ni_usb_bulk_complete(struct urb *urb) 88 { 89 struct ni_usb_urb_ctx *context = urb->context; 90 91 complete(&context->complete); 92 } 93 94 static void ni_usb_timeout_handler(struct timer_list *t) 95 { 96 struct ni_usb_priv *ni_priv = timer_container_of(ni_priv, t, 97 bulk_timer); 98 struct ni_usb_urb_ctx *context = &ni_priv->context; 99 100 context->timed_out = 1; 101 complete(&context->complete); 102 }; 103 104 // I'm using nonblocking loosely here, it only means -EAGAIN can be returned in certain cases 105 static int ni_usb_nonblocking_send_bulk_msg(struct ni_usb_priv *ni_priv, void *data, 106 int data_length, int *actual_data_length, 107 int timeout_msecs) 108 { 109 struct usb_device *usb_dev; 110 int retval; 111 unsigned int out_pipe; 112 struct ni_usb_urb_ctx *context = &ni_priv->context; 113 114 *actual_data_length = 0; 115 mutex_lock(&ni_priv->bulk_transfer_lock); 116 if (!ni_priv->bus_interface) { 117 mutex_unlock(&ni_priv->bulk_transfer_lock); 118 return -ENODEV; 119 } 120 if (ni_priv->bulk_urb) { 121 mutex_unlock(&ni_priv->bulk_transfer_lock); 122 return -EAGAIN; 123 } 124 ni_priv->bulk_urb = usb_alloc_urb(0, GFP_KERNEL); 125 if (!ni_priv->bulk_urb) { 126 mutex_unlock(&ni_priv->bulk_transfer_lock); 127 return -ENOMEM; 128 } 129 usb_dev = interface_to_usbdev(ni_priv->bus_interface); 130 out_pipe = usb_sndbulkpipe(usb_dev, ni_priv->bulk_out_endpoint); 131 init_completion(&context->complete); 132 context->timed_out = 0; 133 usb_fill_bulk_urb(ni_priv->bulk_urb, usb_dev, out_pipe, data, data_length, 134 &ni_usb_bulk_complete, context); 135 136 if (timeout_msecs) 137 mod_timer(&ni_priv->bulk_timer, jiffies + msecs_to_jiffies(timeout_msecs)); 138 139 retval = usb_submit_urb(ni_priv->bulk_urb, GFP_KERNEL); 140 if (retval) { 141 timer_delete_sync(&ni_priv->bulk_timer); 142 usb_free_urb(ni_priv->bulk_urb); 143 ni_priv->bulk_urb = NULL; 144 dev_err(&usb_dev->dev, "failed to submit bulk out urb, retval=%i\n", 145 retval); 146 mutex_unlock(&ni_priv->bulk_transfer_lock); 147 return retval; 148 } 149 mutex_unlock(&ni_priv->bulk_transfer_lock); 150 wait_for_completion(&context->complete); // wait for ni_usb_bulk_complete 151 if (context->timed_out) { 152 usb_kill_urb(ni_priv->bulk_urb); 153 dev_err(&usb_dev->dev, "killed urb due to timeout\n"); 154 retval = -ETIMEDOUT; 155 } else { 156 retval = ni_priv->bulk_urb->status; 157 } 158 159 timer_delete_sync(&ni_priv->bulk_timer); 160 *actual_data_length = ni_priv->bulk_urb->actual_length; 161 mutex_lock(&ni_priv->bulk_transfer_lock); 162 usb_free_urb(ni_priv->bulk_urb); 163 ni_priv->bulk_urb = NULL; 164 mutex_unlock(&ni_priv->bulk_transfer_lock); 165 return retval; 166 } 167 168 static int ni_usb_send_bulk_msg(struct ni_usb_priv *ni_priv, void *data, int data_length, 169 int *actual_data_length, int timeout_msecs) 170 { 171 int retval; 172 int timeout_msecs_remaining = timeout_msecs; 173 174 retval = ni_usb_nonblocking_send_bulk_msg(ni_priv, data, data_length, actual_data_length, 175 timeout_msecs_remaining); 176 while (retval == -EAGAIN && (timeout_msecs == 0 || timeout_msecs_remaining > 0)) { 177 usleep_range(1000, 1500); 178 retval = ni_usb_nonblocking_send_bulk_msg(ni_priv, data, data_length, 179 actual_data_length, 180 timeout_msecs_remaining); 181 if (timeout_msecs != 0) 182 --timeout_msecs_remaining; 183 } 184 if (timeout_msecs != 0 && timeout_msecs_remaining <= 0) 185 return -ETIMEDOUT; 186 return retval; 187 } 188 189 // I'm using nonblocking loosely here, it only means -EAGAIN can be returned in certain cases 190 static int ni_usb_nonblocking_receive_bulk_msg(struct ni_usb_priv *ni_priv, 191 void *data, int data_length, 192 int *actual_data_length, int timeout_msecs, 193 int interruptible) 194 { 195 struct usb_device *usb_dev; 196 int retval; 197 unsigned int in_pipe; 198 struct ni_usb_urb_ctx *context = &ni_priv->context; 199 200 *actual_data_length = 0; 201 mutex_lock(&ni_priv->bulk_transfer_lock); 202 if (!ni_priv->bus_interface) { 203 mutex_unlock(&ni_priv->bulk_transfer_lock); 204 return -ENODEV; 205 } 206 if (ni_priv->bulk_urb) { 207 mutex_unlock(&ni_priv->bulk_transfer_lock); 208 return -EAGAIN; 209 } 210 ni_priv->bulk_urb = usb_alloc_urb(0, GFP_KERNEL); 211 if (!ni_priv->bulk_urb) { 212 mutex_unlock(&ni_priv->bulk_transfer_lock); 213 return -ENOMEM; 214 } 215 usb_dev = interface_to_usbdev(ni_priv->bus_interface); 216 in_pipe = usb_rcvbulkpipe(usb_dev, ni_priv->bulk_in_endpoint); 217 init_completion(&context->complete); 218 context->timed_out = 0; 219 usb_fill_bulk_urb(ni_priv->bulk_urb, usb_dev, in_pipe, data, data_length, 220 &ni_usb_bulk_complete, context); 221 222 if (timeout_msecs) 223 mod_timer(&ni_priv->bulk_timer, jiffies + msecs_to_jiffies(timeout_msecs)); 224 225 retval = usb_submit_urb(ni_priv->bulk_urb, GFP_KERNEL); 226 if (retval) { 227 timer_delete_sync(&ni_priv->bulk_timer); 228 usb_free_urb(ni_priv->bulk_urb); 229 ni_priv->bulk_urb = NULL; 230 dev_err(&usb_dev->dev, "failed to submit bulk in urb, retval=%i\n", retval); 231 mutex_unlock(&ni_priv->bulk_transfer_lock); 232 return retval; 233 } 234 mutex_unlock(&ni_priv->bulk_transfer_lock); 235 if (interruptible) { 236 if (wait_for_completion_interruptible(&context->complete)) { 237 /* 238 * If we got interrupted by a signal while 239 * waiting for the usb gpib to respond, we 240 * should send a stop command so it will 241 * finish up with whatever it was doing and 242 * send its response now. 243 */ 244 ni_usb_stop(ni_priv); 245 retval = -ERESTARTSYS; 246 /* 247 * now do an uninterruptible wait, it shouldn't take long 248 * for the board to respond now. 249 */ 250 wait_for_completion(&context->complete); 251 } 252 } else { 253 wait_for_completion(&context->complete); 254 } 255 if (context->timed_out) { 256 usb_kill_urb(ni_priv->bulk_urb); 257 dev_err(&usb_dev->dev, "killed urb due to timeout\n"); 258 retval = -ETIMEDOUT; 259 } else { 260 if (ni_priv->bulk_urb->status) 261 retval = ni_priv->bulk_urb->status; 262 } 263 timer_delete_sync(&ni_priv->bulk_timer); 264 *actual_data_length = ni_priv->bulk_urb->actual_length; 265 mutex_lock(&ni_priv->bulk_transfer_lock); 266 usb_free_urb(ni_priv->bulk_urb); 267 ni_priv->bulk_urb = NULL; 268 mutex_unlock(&ni_priv->bulk_transfer_lock); 269 return retval; 270 } 271 272 static int ni_usb_receive_bulk_msg(struct ni_usb_priv *ni_priv, void *data, 273 int data_length, int *actual_data_length, int timeout_msecs, 274 int interruptible) 275 { 276 int retval; 277 int timeout_msecs_remaining = timeout_msecs; 278 279 retval = ni_usb_nonblocking_receive_bulk_msg(ni_priv, data, data_length, 280 actual_data_length, timeout_msecs_remaining, 281 interruptible); 282 while (retval == -EAGAIN && (timeout_msecs == 0 || timeout_msecs_remaining > 0)) { 283 usleep_range(1000, 1500); 284 retval = ni_usb_nonblocking_receive_bulk_msg(ni_priv, data, data_length, 285 actual_data_length, 286 timeout_msecs_remaining, 287 interruptible); 288 if (timeout_msecs != 0) 289 --timeout_msecs_remaining; 290 } 291 if (timeout_msecs && timeout_msecs_remaining <= 0) 292 return -ETIMEDOUT; 293 return retval; 294 } 295 296 static int ni_usb_receive_control_msg(struct ni_usb_priv *ni_priv, __u8 request, 297 __u8 requesttype, __u16 value, __u16 index, 298 void *data, __u16 size, int timeout_msecs) 299 { 300 struct usb_device *usb_dev; 301 int retval; 302 unsigned int in_pipe; 303 304 mutex_lock(&ni_priv->control_transfer_lock); 305 if (!ni_priv->bus_interface) { 306 mutex_unlock(&ni_priv->control_transfer_lock); 307 return -ENODEV; 308 } 309 usb_dev = interface_to_usbdev(ni_priv->bus_interface); 310 in_pipe = usb_rcvctrlpipe(usb_dev, 0); 311 retval = usb_control_msg(usb_dev, in_pipe, request, requesttype, value, index, data, 312 size, timeout_msecs); 313 mutex_unlock(&ni_priv->control_transfer_lock); 314 return retval; 315 } 316 317 static void ni_usb_soft_update_status(struct gpib_board *board, unsigned int ni_usb_ibsta, 318 unsigned int clear_mask) 319 { 320 static const unsigned int ni_usb_ibsta_mask = SRQI | ATN | CIC | REM | LACS | TACS | LOK; 321 322 struct ni_usb_priv *ni_priv = board->private_data; 323 struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); 324 unsigned int need_monitoring_bits = ni_usb_ibsta_monitor_mask; 325 unsigned long flags; 326 327 board->status &= ~clear_mask; 328 board->status &= ~ni_usb_ibsta_mask; 329 board->status |= ni_usb_ibsta & ni_usb_ibsta_mask; 330 if (ni_usb_ibsta & DCAS) 331 push_gpib_event(board, EVENT_DEV_CLR); 332 if (ni_usb_ibsta & DTAS) 333 push_gpib_event(board, EVENT_DEV_TRG); 334 335 spin_lock_irqsave(&board->spinlock, flags); 336 /* remove set status bits from monitored set why ?***/ 337 ni_priv->monitored_ibsta_bits &= ~ni_usb_ibsta; 338 need_monitoring_bits &= ~ni_priv->monitored_ibsta_bits; /* mm - monitored set */ 339 spin_unlock_irqrestore(&board->spinlock, flags); 340 dev_dbg(&usb_dev->dev, "need_monitoring_bits=0x%x\n", need_monitoring_bits); 341 342 if (need_monitoring_bits & ~ni_usb_ibsta) 343 ni_usb_set_interrupt_monitor(board, ni_usb_ibsta_monitor_mask); 344 else if (need_monitoring_bits & ni_usb_ibsta) 345 wake_up_interruptible(&board->wait); 346 347 dev_dbg(&usb_dev->dev, "ibsta=0x%x\n", ni_usb_ibsta); 348 } 349 350 static int ni_usb_parse_status_block(const u8 *buffer, struct ni_usb_status_block *status) 351 { 352 u16 count; 353 354 status->id = buffer[0]; 355 status->ibsta = (buffer[1] << 8) | buffer[2]; 356 status->error_code = buffer[3]; 357 count = buffer[4] | (buffer[5] << 8); 358 count = ~count; 359 count++; 360 status->count = count; 361 return 8; 362 }; 363 364 static void ni_usb_dump_raw_block(const u8 *raw_data, int length) 365 { 366 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 8, 1, raw_data, length, true); 367 } 368 369 static int ni_usb_parse_register_read_block(const u8 *raw_data, unsigned int *results, 370 int num_results) 371 { 372 int i = 0; 373 int j; 374 int unexpected = 0; 375 static const int results_per_chunk = 3; 376 377 for (j = 0; j < num_results;) { 378 int k; 379 380 if (raw_data[i++] != NIUSB_REGISTER_READ_DATA_START_ID) { 381 pr_err("parse error: wrong start id\n"); 382 unexpected = 1; 383 } 384 for (k = 0; k < results_per_chunk && j < num_results; ++k) 385 results[j++] = raw_data[i++]; 386 } 387 while (i % 4) 388 i++; 389 if (raw_data[i++] != NIUSB_REGISTER_READ_DATA_END_ID) { 390 pr_err("parse error: wrong end id\n"); 391 unexpected = 1; 392 } 393 if (raw_data[i++] % results_per_chunk != num_results % results_per_chunk) { 394 pr_err("parse error: wrong count=%i for NIUSB_REGISTER_READ_DATA_END\n", 395 (int)raw_data[i - 1]); 396 unexpected = 1; 397 } 398 while (i % 4) { 399 if (raw_data[i++] != 0) { 400 pr_err("unexpected data: raw_data[%i]=0x%x, expected 0\n", 401 i - 1, (int)raw_data[i - 1]); 402 unexpected = 1; 403 } 404 } 405 if (unexpected) 406 ni_usb_dump_raw_block(raw_data, i); 407 return i; 408 } 409 410 static int ni_usb_parse_termination_block(const u8 *buffer) 411 { 412 int i = 0; 413 414 if (buffer[i++] != NIUSB_TERM_ID || 415 buffer[i++] != 0x0 || 416 buffer[i++] != 0x0 || 417 buffer[i++] != 0x0) { 418 pr_err("received unexpected termination block\n"); 419 pr_err(" expected: 0x%x 0x%x 0x%x 0x%x\n", NIUSB_TERM_ID, 0x0, 0x0, 0x0); 420 pr_err(" received: 0x%x 0x%x 0x%x 0x%x\n", 421 buffer[i - 4], buffer[i - 3], buffer[i - 2], buffer[i - 1]); 422 } 423 return i; 424 }; 425 426 static int parse_board_ibrd_readback(const u8 *raw_data, struct ni_usb_status_block *status, 427 u8 *parsed_data, int parsed_data_length, 428 int *actual_bytes_read) 429 { 430 static const int ibrd_data_block_length = 0xf; 431 static const int ibrd_extended_data_block_length = 0x1e; 432 int data_block_length = 0; 433 int i = 0; 434 int j = 0; 435 int k; 436 int num_data_blocks = 0; 437 struct ni_usb_status_block register_write_status; 438 int unexpected = 0; 439 440 while (raw_data[i] == NIUSB_IBRD_DATA_ID || raw_data[i] == NIUSB_IBRD_EXTENDED_DATA_ID) { 441 if (raw_data[i] == NIUSB_IBRD_DATA_ID) { 442 data_block_length = ibrd_data_block_length; 443 } else if (raw_data[i] == NIUSB_IBRD_EXTENDED_DATA_ID) { 444 data_block_length = ibrd_extended_data_block_length; 445 if (raw_data[++i] != 0) { 446 pr_err("unexpected data: raw_data[%i]=0x%x, expected 0\n", 447 i, (int)raw_data[i]); 448 unexpected = 1; 449 } 450 } else { 451 pr_err("Unexpected NIUSB_IBRD ID\n"); 452 return -EINVAL; 453 } 454 ++i; 455 for (k = 0; k < data_block_length; k++) { 456 if (j < parsed_data_length) 457 parsed_data[j++] = raw_data[i++]; 458 else 459 ++i; 460 } 461 ++num_data_blocks; 462 } 463 i += ni_usb_parse_status_block(&raw_data[i], status); 464 if (status->id != NIUSB_IBRD_STATUS_ID) { 465 pr_err("bug: status->id=%i, != ibrd_status_id\n", status->id); 466 return -EIO; 467 } 468 i++; 469 if (num_data_blocks) { 470 *actual_bytes_read = (num_data_blocks - 1) * data_block_length + raw_data[i++]; 471 } else { 472 ++i; 473 *actual_bytes_read = 0; 474 } 475 if (*actual_bytes_read > j) 476 pr_err("bug: discarded data. actual_bytes_read=%i, j=%i\n", *actual_bytes_read, j); 477 for (k = 0; k < 2; k++) 478 if (raw_data[i++] != 0) { 479 pr_err("unexpected data: raw_data[%i]=0x%x, expected 0\n", 480 i - 1, (int)raw_data[i - 1]); 481 unexpected = 1; 482 } 483 i += ni_usb_parse_status_block(&raw_data[i], ®ister_write_status); 484 if (register_write_status.id != NIUSB_REG_WRITE_ID) { 485 pr_err("unexpected data: register write status id=0x%x, expected 0x%x\n", 486 register_write_status.id, NIUSB_REG_WRITE_ID); 487 unexpected = 1; 488 } 489 if (raw_data[i++] != 2) { 490 pr_err("unexpected data: register write count=%i, expected 2\n", 491 (int)raw_data[i - 1]); 492 unexpected = 1; 493 } 494 for (k = 0; k < 3; k++) 495 if (raw_data[i++] != 0) { 496 pr_err("unexpected data: raw_data[%i]=0x%x, expected 0\n", 497 i - 1, (int)raw_data[i - 1]); 498 unexpected = 1; 499 } 500 i += ni_usb_parse_termination_block(&raw_data[i]); 501 if (unexpected) 502 ni_usb_dump_raw_block(raw_data, i); 503 return i; 504 } 505 506 static int ni_usb_parse_reg_write_status_block(const u8 *raw_data, 507 struct ni_usb_status_block *status, 508 int *writes_completed) 509 { 510 int i = 0; 511 512 i += ni_usb_parse_status_block(raw_data, status); 513 *writes_completed = raw_data[i++]; 514 while (i % 4) 515 i++; 516 return i; 517 } 518 519 static int ni_usb_write_registers(struct ni_usb_priv *ni_priv, 520 const struct ni_usb_register *writes, int num_writes, 521 unsigned int *ibsta) 522 { 523 struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); 524 int retval; 525 u8 *out_data, *in_data; 526 int out_data_length; 527 static const int in_data_length = 0x20; 528 int bytes_written = 0, bytes_read = 0; 529 int i = 0; 530 int j; 531 struct ni_usb_status_block status; 532 static const int bytes_per_write = 3; 533 int reg_writes_completed; 534 535 out_data_length = num_writes * bytes_per_write + 0x10; 536 out_data = kmalloc(out_data_length, GFP_KERNEL); 537 if (!out_data) 538 return -ENOMEM; 539 i += ni_usb_bulk_register_write_header(&out_data[i], num_writes); 540 for (j = 0; j < num_writes; j++) 541 i += ni_usb_bulk_register_write(&out_data[i], writes[j]); 542 while (i % 4) 543 out_data[i++] = 0x00; 544 i += ni_usb_bulk_termination(&out_data[i]); 545 546 mutex_lock(&ni_priv->addressed_transfer_lock); 547 548 retval = ni_usb_send_bulk_msg(ni_priv, out_data, i, &bytes_written, 1000); 549 kfree(out_data); 550 if (retval) { 551 mutex_unlock(&ni_priv->addressed_transfer_lock); 552 dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n", 553 retval, bytes_written, i); 554 return retval; 555 } 556 557 in_data = kmalloc(in_data_length, GFP_KERNEL); 558 if (!in_data) { 559 mutex_unlock(&ni_priv->addressed_transfer_lock); 560 return -ENOMEM; 561 } 562 retval = ni_usb_receive_bulk_msg(ni_priv, in_data, in_data_length, &bytes_read, 1000, 0); 563 if (retval || bytes_read != 16) { 564 mutex_unlock(&ni_priv->addressed_transfer_lock); 565 dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n", 566 retval, bytes_read); 567 ni_usb_dump_raw_block(in_data, bytes_read); 568 kfree(in_data); 569 return retval; 570 } 571 572 mutex_unlock(&ni_priv->addressed_transfer_lock); 573 574 ni_usb_parse_reg_write_status_block(in_data, &status, ®_writes_completed); 575 // FIXME parse extra 09 status bits and termination 576 kfree(in_data); 577 if (status.id != NIUSB_REG_WRITE_ID) { 578 dev_err(&usb_dev->dev, "parse error, id=0x%x != NIUSB_REG_WRITE_ID\n", status.id); 579 return -EIO; 580 } 581 if (status.error_code) { 582 dev_err(&usb_dev->dev, "nonzero error code 0x%x\n", status.error_code); 583 return -EIO; 584 } 585 if (reg_writes_completed != num_writes) { 586 dev_err(&usb_dev->dev, "reg_writes_completed=%i, num_writes=%i\n", 587 reg_writes_completed, num_writes); 588 return -EIO; 589 } 590 if (ibsta) 591 *ibsta = status.ibsta; 592 return 0; 593 } 594 595 // interface functions 596 static int ni_usb_read(struct gpib_board *board, u8 *buffer, size_t length, 597 int *end, size_t *bytes_read) 598 { 599 int retval, parse_retval; 600 struct ni_usb_priv *ni_priv = board->private_data; 601 struct usb_device *usb_dev; 602 u8 *out_data, *in_data; 603 static const int out_data_length = 0x20; 604 int in_data_length; 605 int usb_bytes_written = 0, usb_bytes_read = 0; 606 int i = 0; 607 int complement_count; 608 int actual_length; 609 struct ni_usb_status_block status; 610 static const int max_read_length = 0xffff; 611 struct ni_usb_register reg; 612 613 *bytes_read = 0; 614 if (!ni_priv->bus_interface) 615 return -ENODEV; 616 if (length > max_read_length) 617 return -EINVAL; 618 usb_dev = interface_to_usbdev(ni_priv->bus_interface); 619 out_data = kmalloc(out_data_length, GFP_KERNEL); 620 if (!out_data) 621 return -ENOMEM; 622 out_data[i++] = 0x0a; 623 out_data[i++] = ni_priv->eos_mode >> 8; 624 out_data[i++] = ni_priv->eos_char; 625 out_data[i++] = ni_usb_timeout_code(board->usec_timeout); 626 complement_count = length - 1; 627 complement_count = ~complement_count; 628 out_data[i++] = complement_count & 0xff; 629 out_data[i++] = (complement_count >> 8) & 0xff; 630 out_data[i++] = 0x0; 631 out_data[i++] = 0x0; 632 i += ni_usb_bulk_register_write_header(&out_data[i], 2); 633 reg.device = NIUSB_SUBDEV_TNT4882; 634 reg.address = nec7210_to_tnt4882_offset(AUXMR); 635 reg.value = AUX_HLDI; 636 i += ni_usb_bulk_register_write(&out_data[i], reg); 637 reg.value = AUX_CLEAR_END; 638 i += ni_usb_bulk_register_write(&out_data[i], reg); 639 while (i % 4) // pad with zeros to 4-byte boundary 640 out_data[i++] = 0x0; 641 i += ni_usb_bulk_termination(&out_data[i]); 642 643 mutex_lock(&ni_priv->addressed_transfer_lock); 644 645 retval = ni_usb_send_bulk_msg(ni_priv, out_data, i, &usb_bytes_written, 1000); 646 kfree(out_data); 647 if (retval || usb_bytes_written != i) { 648 if (retval == 0) 649 retval = -EIO; 650 dev_err(&usb_dev->dev, "send_bulk_msg returned %i, usb_bytes_written=%i, i=%i\n", 651 retval, usb_bytes_written, i); 652 mutex_unlock(&ni_priv->addressed_transfer_lock); 653 return retval; 654 } 655 656 in_data_length = (length / 30 + 1) * 0x20 + 0x20; 657 in_data = kmalloc(in_data_length, GFP_KERNEL); 658 if (!in_data) { 659 mutex_unlock(&ni_priv->addressed_transfer_lock); 660 return -ENOMEM; 661 } 662 retval = ni_usb_receive_bulk_msg(ni_priv, in_data, in_data_length, &usb_bytes_read, 663 ni_usb_timeout_msecs(board->usec_timeout), 1); 664 665 mutex_unlock(&ni_priv->addressed_transfer_lock); 666 667 if (retval == -ERESTARTSYS) { 668 } else if (retval) { 669 dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, usb_bytes_read=%i\n", 670 retval, usb_bytes_read); 671 kfree(in_data); 672 return retval; 673 } 674 parse_retval = parse_board_ibrd_readback(in_data, &status, buffer, length, &actual_length); 675 if (parse_retval != usb_bytes_read) { 676 if (parse_retval >= 0) 677 parse_retval = -EIO; 678 dev_err(&usb_dev->dev, "retval=%i usb_bytes_read=%i\n", 679 parse_retval, usb_bytes_read); 680 kfree(in_data); 681 return parse_retval; 682 } 683 if (actual_length != length - status.count) { 684 dev_err(&usb_dev->dev, "actual_length=%i expected=%li\n", 685 actual_length, (long)(length - status.count)); 686 ni_usb_dump_raw_block(in_data, usb_bytes_read); 687 } 688 kfree(in_data); 689 switch (status.error_code) { 690 case NIUSB_NO_ERROR: 691 retval = 0; 692 break; 693 case NIUSB_ABORTED_ERROR: 694 /* 695 * this is expected if ni_usb_receive_bulk_msg got 696 * interrupted by a signal and returned -ERESTARTSYS 697 */ 698 break; 699 case NIUSB_ATN_STATE_ERROR: 700 if (status.ibsta & DCAS) { 701 retval = -EINTR; 702 } else { 703 retval = -EIO; 704 dev_dbg(&usb_dev->dev, "read when ATN set stat: 0x%06x\n", status.ibsta); 705 } 706 break; 707 case NIUSB_ADDRESSING_ERROR: 708 retval = -EIO; 709 break; 710 case NIUSB_TIMEOUT_ERROR: 711 retval = -ETIMEDOUT; 712 break; 713 case NIUSB_EOSMODE_ERROR: 714 dev_err(&usb_dev->dev, "driver bug, we should have been able to avoid NIUSB_EOSMODE_ERROR.\n"); 715 retval = -EINVAL; 716 break; 717 default: 718 dev_err(&usb_dev->dev, "unknown error code=%i\n", status.error_code); 719 retval = -EIO; 720 break; 721 } 722 ni_usb_soft_update_status(board, status.ibsta, 0); 723 if (status.ibsta & END) 724 *end = 1; 725 else 726 *end = 0; 727 *bytes_read = actual_length; 728 return retval; 729 } 730 731 static int ni_usb_write(struct gpib_board *board, u8 *buffer, size_t length, 732 int send_eoi, size_t *bytes_written) 733 { 734 int retval; 735 struct ni_usb_priv *ni_priv = board->private_data; 736 struct usb_device *usb_dev; 737 u8 *out_data, *in_data; 738 int out_data_length; 739 static const int in_data_length = 0x10; 740 int usb_bytes_written = 0, usb_bytes_read = 0; 741 int i = 0, j; 742 int complement_count; 743 struct ni_usb_status_block status; 744 static const int max_write_length = 0xffff; 745 746 if (!ni_priv->bus_interface) 747 return -ENODEV; 748 if (length > max_write_length) 749 return -EINVAL; 750 usb_dev = interface_to_usbdev(ni_priv->bus_interface); 751 out_data_length = length + 0x10; 752 out_data = kmalloc(out_data_length, GFP_KERNEL); 753 if (!out_data) 754 return -ENOMEM; 755 out_data[i++] = 0x0d; 756 complement_count = length - 1; 757 complement_count = ~complement_count; 758 out_data[i++] = complement_count & 0xff; 759 out_data[i++] = (complement_count >> 8) & 0xff; 760 out_data[i++] = ni_usb_timeout_code(board->usec_timeout); 761 out_data[i++] = 0x0; 762 out_data[i++] = 0x0; 763 if (send_eoi) 764 out_data[i++] = 0x8; 765 else 766 out_data[i++] = 0x0; 767 out_data[i++] = 0x0; 768 for (j = 0; j < length; j++) 769 out_data[i++] = buffer[j]; 770 while (i % 4) // pad with zeros to 4-byte boundary 771 out_data[i++] = 0x0; 772 i += ni_usb_bulk_termination(&out_data[i]); 773 774 mutex_lock(&ni_priv->addressed_transfer_lock); 775 776 retval = ni_usb_send_bulk_msg(ni_priv, out_data, i, &usb_bytes_written, 777 ni_usb_timeout_msecs(board->usec_timeout)); 778 kfree(out_data); 779 if (retval || usb_bytes_written != i) { 780 mutex_unlock(&ni_priv->addressed_transfer_lock); 781 dev_err(&usb_dev->dev, "send_bulk_msg returned %i, usb_bytes_written=%i, i=%i\n", 782 retval, usb_bytes_written, i); 783 return retval; 784 } 785 786 in_data = kmalloc(in_data_length, GFP_KERNEL); 787 if (!in_data) { 788 mutex_unlock(&ni_priv->addressed_transfer_lock); 789 return -ENOMEM; 790 } 791 retval = ni_usb_receive_bulk_msg(ni_priv, in_data, in_data_length, &usb_bytes_read, 792 ni_usb_timeout_msecs(board->usec_timeout), 1); 793 794 mutex_unlock(&ni_priv->addressed_transfer_lock); 795 796 if ((retval && retval != -ERESTARTSYS) || usb_bytes_read != 12) { 797 dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, usb_bytes_read=%i\n", 798 retval, usb_bytes_read); 799 kfree(in_data); 800 return retval; 801 } 802 ni_usb_parse_status_block(in_data, &status); 803 kfree(in_data); 804 switch (status.error_code) { 805 case NIUSB_NO_ERROR: 806 retval = 0; 807 break; 808 case NIUSB_ABORTED_ERROR: 809 /* 810 * this is expected if ni_usb_receive_bulk_msg got 811 * interrupted by a signal and returned -ERESTARTSYS 812 */ 813 break; 814 case NIUSB_ADDRESSING_ERROR: 815 dev_err(&usb_dev->dev, "Addressing error retval %d error code=%i\n", 816 retval, status.error_code); 817 retval = -ENXIO; 818 break; 819 case NIUSB_NO_LISTENER_ERROR: 820 retval = -ECOMM; 821 break; 822 case NIUSB_TIMEOUT_ERROR: 823 retval = -ETIMEDOUT; 824 break; 825 default: 826 dev_err(&usb_dev->dev, "unknown error code=%i\n", status.error_code); 827 retval = -EPIPE; 828 break; 829 } 830 ni_usb_soft_update_status(board, status.ibsta, 0); 831 *bytes_written = length - status.count; 832 return retval; 833 } 834 835 static int ni_usb_command_chunk(struct gpib_board *board, u8 *buffer, size_t length, 836 size_t *command_bytes_written) 837 { 838 int retval; 839 struct ni_usb_priv *ni_priv = board->private_data; 840 struct usb_device *usb_dev; 841 u8 *out_data, *in_data; 842 int out_data_length; 843 static const int in_data_length = 0x10; 844 int bytes_written = 0, bytes_read = 0; 845 int i = 0, j; 846 unsigned int complement_count; 847 struct ni_usb_status_block status; 848 // usb-b gives error 4 if you try to send more than 16 command bytes at once 849 static const int max_command_length = 0x10; 850 851 *command_bytes_written = 0; 852 if (!ni_priv->bus_interface) 853 return -ENODEV; 854 if (length > max_command_length) 855 length = max_command_length; 856 usb_dev = interface_to_usbdev(ni_priv->bus_interface); 857 out_data_length = length + 0x10; 858 out_data = kmalloc(out_data_length, GFP_KERNEL); 859 if (!out_data) 860 return -ENOMEM; 861 out_data[i++] = 0x0c; 862 complement_count = length - 1; 863 complement_count = ~complement_count; 864 out_data[i++] = complement_count; 865 out_data[i++] = 0x0; 866 out_data[i++] = ni_usb_timeout_code(board->usec_timeout); 867 for (j = 0; j < length; j++) 868 out_data[i++] = buffer[j]; 869 while (i % 4) // pad with zeros to 4-byte boundary 870 out_data[i++] = 0x0; 871 i += ni_usb_bulk_termination(&out_data[i]); 872 873 mutex_lock(&ni_priv->addressed_transfer_lock); 874 875 retval = ni_usb_send_bulk_msg(ni_priv, out_data, i, &bytes_written, 876 ni_usb_timeout_msecs(board->usec_timeout)); 877 kfree(out_data); 878 if (retval || bytes_written != i) { 879 mutex_unlock(&ni_priv->addressed_transfer_lock); 880 dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n", 881 retval, bytes_written, i); 882 return retval; 883 } 884 885 in_data = kmalloc(in_data_length, GFP_KERNEL); 886 if (!in_data) { 887 mutex_unlock(&ni_priv->addressed_transfer_lock); 888 return -ENOMEM; 889 } 890 891 retval = ni_usb_receive_bulk_msg(ni_priv, in_data, in_data_length, &bytes_read, 892 ni_usb_timeout_msecs(board->usec_timeout), 1); 893 894 mutex_unlock(&ni_priv->addressed_transfer_lock); 895 896 if ((retval && retval != -ERESTARTSYS) || bytes_read != 12) { 897 dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n", 898 retval, bytes_read); 899 kfree(in_data); 900 return retval; 901 } 902 ni_usb_parse_status_block(in_data, &status); 903 kfree(in_data); 904 *command_bytes_written = length - status.count; 905 switch (status.error_code) { 906 case NIUSB_NO_ERROR: 907 break; 908 case NIUSB_ABORTED_ERROR: 909 /* 910 * this is expected if ni_usb_receive_bulk_msg got 911 * interrupted by a signal and returned -ERESTARTSYS 912 */ 913 break; 914 case NIUSB_NO_BUS_ERROR: 915 return -ENOTCONN; 916 case NIUSB_EOSMODE_ERROR: 917 dev_err(&usb_dev->dev, "got eosmode error. Driver bug?\n"); 918 return -EIO; 919 case NIUSB_TIMEOUT_ERROR: 920 return -ETIMEDOUT; 921 default: 922 dev_err(&usb_dev->dev, "unknown error code=%i\n", status.error_code); 923 return -EIO; 924 } 925 ni_usb_soft_update_status(board, status.ibsta, 0); 926 return 0; 927 } 928 929 static int ni_usb_command(struct gpib_board *board, u8 *buffer, size_t length, 930 size_t *bytes_written) 931 { 932 size_t count; 933 int retval; 934 935 *bytes_written = 0; 936 while (*bytes_written < length) { 937 retval = ni_usb_command_chunk(board, buffer + *bytes_written, 938 length - *bytes_written, &count); 939 *bytes_written += count; 940 if (retval < 0) 941 return retval; 942 } 943 return 0; 944 } 945 946 static int ni_usb_take_control(struct gpib_board *board, int synchronous) 947 { 948 int retval; 949 struct ni_usb_priv *ni_priv = board->private_data; 950 struct usb_device *usb_dev; 951 u8 *out_data, *in_data; 952 static const int out_data_length = 0x10; 953 static const int in_data_length = 0x10; 954 int bytes_written = 0, bytes_read = 0; 955 int i = 0; 956 struct ni_usb_status_block status; 957 958 if (!ni_priv->bus_interface) 959 return -ENODEV; 960 usb_dev = interface_to_usbdev(ni_priv->bus_interface); 961 out_data = kmalloc(out_data_length, GFP_KERNEL); 962 if (!out_data) 963 return -ENOMEM; 964 out_data[i++] = NIUSB_IBCAC_ID; 965 if (synchronous) 966 out_data[i++] = 0x1; 967 else 968 out_data[i++] = 0x0; 969 out_data[i++] = 0x0; 970 out_data[i++] = 0x0; 971 i += ni_usb_bulk_termination(&out_data[i]); 972 973 mutex_lock(&ni_priv->addressed_transfer_lock); 974 975 retval = ni_usb_send_bulk_msg(ni_priv, out_data, i, &bytes_written, 1000); 976 kfree(out_data); 977 if (retval || bytes_written != i) { 978 mutex_unlock(&ni_priv->addressed_transfer_lock); 979 dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n", 980 retval, bytes_written, i); 981 return retval; 982 } 983 984 in_data = kmalloc(in_data_length, GFP_KERNEL); 985 if (!in_data) { 986 mutex_unlock(&ni_priv->addressed_transfer_lock); 987 return -ENOMEM; 988 } 989 retval = ni_usb_receive_bulk_msg(ni_priv, in_data, in_data_length, &bytes_read, 1000, 1); 990 991 mutex_unlock(&ni_priv->addressed_transfer_lock); 992 993 if ((retval && retval != -ERESTARTSYS) || bytes_read != 12) { 994 if (retval == 0) 995 retval = -EIO; 996 dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n", 997 retval, bytes_read); 998 kfree(in_data); 999 return retval; 1000 } 1001 ni_usb_parse_status_block(in_data, &status); 1002 kfree(in_data); 1003 ni_usb_soft_update_status(board, status.ibsta, 0); 1004 return retval; 1005 } 1006 1007 static int ni_usb_go_to_standby(struct gpib_board *board) 1008 { 1009 int retval; 1010 struct ni_usb_priv *ni_priv = board->private_data; 1011 struct usb_device *usb_dev; 1012 u8 *out_data, *in_data; 1013 static const int out_data_length = 0x10; 1014 static const int in_data_length = 0x20; 1015 int bytes_written = 0, bytes_read = 0; 1016 int i = 0; 1017 struct ni_usb_status_block status; 1018 1019 if (!ni_priv->bus_interface) 1020 return -ENODEV; 1021 usb_dev = interface_to_usbdev(ni_priv->bus_interface); 1022 out_data = kmalloc(out_data_length, GFP_KERNEL); 1023 if (!out_data) 1024 return -ENOMEM; 1025 1026 out_data[i++] = NIUSB_IBGTS_ID; 1027 out_data[i++] = 0x0; 1028 out_data[i++] = 0x0; 1029 out_data[i++] = 0x0; 1030 i += ni_usb_bulk_termination(&out_data[i]); 1031 1032 mutex_lock(&ni_priv->addressed_transfer_lock); 1033 1034 retval = ni_usb_send_bulk_msg(ni_priv, out_data, i, &bytes_written, 1000); 1035 kfree(out_data); 1036 if (retval || bytes_written != i) { 1037 mutex_unlock(&ni_priv->addressed_transfer_lock); 1038 dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n", 1039 retval, bytes_written, i); 1040 return retval; 1041 } 1042 1043 in_data = kmalloc(in_data_length, GFP_KERNEL); 1044 if (!in_data) { 1045 mutex_unlock(&ni_priv->addressed_transfer_lock); 1046 return -ENOMEM; 1047 } 1048 retval = ni_usb_receive_bulk_msg(ni_priv, in_data, in_data_length, &bytes_read, 1000, 0); 1049 1050 mutex_unlock(&ni_priv->addressed_transfer_lock); 1051 1052 if (retval || bytes_read != 12) { 1053 dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n", 1054 retval, bytes_read); 1055 kfree(in_data); 1056 return retval; 1057 } 1058 ni_usb_parse_status_block(in_data, &status); 1059 kfree(in_data); 1060 if (status.id != NIUSB_IBGTS_ID) 1061 dev_err(&usb_dev->dev, "bug: status.id 0x%x != INUSB_IBGTS_ID\n", status.id); 1062 ni_usb_soft_update_status(board, status.ibsta, 0); 1063 return 0; 1064 } 1065 1066 static int ni_usb_request_system_control(struct gpib_board *board, int request_control) 1067 { 1068 int retval; 1069 struct ni_usb_priv *ni_priv = board->private_data; 1070 struct usb_device *usb_dev; 1071 int i = 0; 1072 struct ni_usb_register writes[4]; 1073 unsigned int ibsta; 1074 1075 if (!ni_priv->bus_interface) 1076 return -ENODEV; 1077 usb_dev = interface_to_usbdev(ni_priv->bus_interface); 1078 if (request_control) { 1079 writes[i].device = NIUSB_SUBDEV_TNT4882; 1080 writes[i].address = CMDR; 1081 writes[i].value = SETSC; 1082 i++; 1083 writes[i].device = NIUSB_SUBDEV_TNT4882; 1084 writes[i].address = nec7210_to_tnt4882_offset(AUXMR); 1085 writes[i].value = AUX_CIFC; 1086 i++; 1087 } else { 1088 writes[i].device = NIUSB_SUBDEV_TNT4882; 1089 writes[i].address = nec7210_to_tnt4882_offset(AUXMR); 1090 writes[i].value = AUX_CREN; 1091 i++; 1092 writes[i].device = NIUSB_SUBDEV_TNT4882; 1093 writes[i].address = nec7210_to_tnt4882_offset(AUXMR); 1094 writes[i].value = AUX_CIFC; 1095 i++; 1096 writes[i].device = NIUSB_SUBDEV_TNT4882; 1097 writes[i].address = nec7210_to_tnt4882_offset(AUXMR); 1098 writes[i].value = AUX_DSC; 1099 i++; 1100 writes[i].device = NIUSB_SUBDEV_TNT4882; 1101 writes[i].address = CMDR; 1102 writes[i].value = CLRSC; 1103 i++; 1104 } 1105 retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta); 1106 if (retval < 0) { 1107 dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval); 1108 return retval; 1109 } 1110 if (!request_control) 1111 ni_priv->ren_state = 0; 1112 ni_usb_soft_update_status(board, ibsta, 0); 1113 return 0; 1114 } 1115 1116 // FIXME maybe the interface should have a "pulse interface clear" function that can return an error? 1117 static void ni_usb_interface_clear(struct gpib_board *board, int assert) 1118 { 1119 int retval; 1120 struct ni_usb_priv *ni_priv = board->private_data; 1121 struct usb_device *usb_dev; 1122 u8 *out_data, *in_data; 1123 static const int out_data_length = 0x10; 1124 static const int in_data_length = 0x10; 1125 int bytes_written = 0, bytes_read = 0; 1126 int i = 0; 1127 struct ni_usb_status_block status; 1128 1129 if (!ni_priv->bus_interface) 1130 return; // -ENODEV; 1131 usb_dev = interface_to_usbdev(ni_priv->bus_interface); 1132 // FIXME: we are going to pulse when assert is true, and ignore otherwise 1133 if (assert == 0) 1134 return; 1135 out_data = kmalloc(out_data_length, GFP_KERNEL); 1136 if (!out_data) 1137 return; 1138 out_data[i++] = NIUSB_IBSIC_ID; 1139 out_data[i++] = 0x0; 1140 out_data[i++] = 0x0; 1141 out_data[i++] = 0x0; 1142 i += ni_usb_bulk_termination(&out_data[i]); 1143 retval = ni_usb_send_bulk_msg(ni_priv, out_data, i, &bytes_written, 1000); 1144 kfree(out_data); 1145 if (retval || bytes_written != i) { 1146 dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n", 1147 retval, bytes_written, i); 1148 return; 1149 } 1150 in_data = kmalloc(in_data_length, GFP_KERNEL); 1151 if (!in_data) 1152 return; 1153 1154 retval = ni_usb_receive_bulk_msg(ni_priv, in_data, in_data_length, &bytes_read, 1000, 0); 1155 if (retval || bytes_read != 12) { 1156 dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n", 1157 retval, bytes_read); 1158 kfree(in_data); 1159 return; 1160 } 1161 ni_usb_parse_status_block(in_data, &status); 1162 kfree(in_data); 1163 ni_usb_soft_update_status(board, status.ibsta, 0); 1164 } 1165 1166 static void ni_usb_remote_enable(struct gpib_board *board, int enable) 1167 { 1168 int retval; 1169 struct ni_usb_priv *ni_priv = board->private_data; 1170 struct usb_device *usb_dev; 1171 struct ni_usb_register reg; 1172 unsigned int ibsta; 1173 1174 if (!ni_priv->bus_interface) 1175 return; // -ENODEV; 1176 usb_dev = interface_to_usbdev(ni_priv->bus_interface); 1177 reg.device = NIUSB_SUBDEV_TNT4882; 1178 reg.address = nec7210_to_tnt4882_offset(AUXMR); 1179 if (enable) 1180 reg.value = AUX_SREN; 1181 else 1182 reg.value = AUX_CREN; 1183 retval = ni_usb_write_registers(ni_priv, ®, 1, &ibsta); 1184 if (retval < 0) { 1185 dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval); 1186 return; //retval; 1187 } 1188 ni_priv->ren_state = enable; 1189 ni_usb_soft_update_status(board, ibsta, 0); 1190 return;// 0; 1191 } 1192 1193 static int ni_usb_enable_eos(struct gpib_board *board, u8 eos_byte, int compare_8_bits) 1194 { 1195 struct ni_usb_priv *ni_priv = board->private_data; 1196 1197 ni_priv->eos_char = eos_byte; 1198 ni_priv->eos_mode |= REOS; 1199 if (compare_8_bits) 1200 ni_priv->eos_mode |= BIN; 1201 else 1202 ni_priv->eos_mode &= ~BIN; 1203 return 0; 1204 } 1205 1206 static void ni_usb_disable_eos(struct gpib_board *board) 1207 { 1208 struct ni_usb_priv *ni_priv = board->private_data; 1209 /* 1210 * adapter gets unhappy if you don't zero all the bits 1211 * for the eos mode and eos char (returns error 4 on reads). 1212 */ 1213 ni_priv->eos_mode = 0; 1214 ni_priv->eos_char = 0; 1215 } 1216 1217 static unsigned int ni_usb_update_status(struct gpib_board *board, unsigned int clear_mask) 1218 { 1219 int retval; 1220 struct ni_usb_priv *ni_priv = board->private_data; 1221 struct usb_device *usb_dev; 1222 static const int buffer_length = 8; 1223 u8 *buffer; 1224 struct ni_usb_status_block status; 1225 1226 if (!ni_priv->bus_interface) 1227 return -ENODEV; 1228 usb_dev = interface_to_usbdev(ni_priv->bus_interface); 1229 buffer = kmalloc(buffer_length, GFP_KERNEL); 1230 if (!buffer) 1231 return board->status; 1232 1233 retval = ni_usb_receive_control_msg(ni_priv, NI_USB_WAIT_REQUEST, USB_DIR_IN | 1234 USB_TYPE_VENDOR | USB_RECIP_DEVICE, 1235 0x200, 0x0, buffer, buffer_length, 1000); 1236 if (retval != buffer_length) { 1237 dev_err(&usb_dev->dev, "usb_control_msg returned %i\n", retval); 1238 kfree(buffer); 1239 return board->status; 1240 } 1241 ni_usb_parse_status_block(buffer, &status); 1242 kfree(buffer); 1243 ni_usb_soft_update_status(board, status.ibsta, clear_mask); 1244 return board->status; 1245 } 1246 1247 // tells ni-usb to immediately stop an ongoing i/o operation 1248 static void ni_usb_stop(struct ni_usb_priv *ni_priv) 1249 { 1250 struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); 1251 int retval; 1252 static const int buffer_length = 8; 1253 u8 *buffer; 1254 struct ni_usb_status_block status; 1255 1256 buffer = kmalloc(buffer_length, GFP_KERNEL); 1257 if (!buffer) 1258 return; 1259 1260 retval = ni_usb_receive_control_msg(ni_priv, NI_USB_STOP_REQUEST, USB_DIR_IN | 1261 USB_TYPE_VENDOR | USB_RECIP_DEVICE, 1262 0x0, 0x0, buffer, buffer_length, 1000); 1263 if (retval != buffer_length) { 1264 dev_err(&usb_dev->dev, "usb_control_msg returned %i\n", retval); 1265 kfree(buffer); 1266 return; 1267 } 1268 ni_usb_parse_status_block(buffer, &status); 1269 kfree(buffer); 1270 } 1271 1272 static int ni_usb_primary_address(struct gpib_board *board, unsigned int address) 1273 { 1274 int retval; 1275 struct ni_usb_priv *ni_priv = board->private_data; 1276 struct usb_device *usb_dev; 1277 int i = 0; 1278 struct ni_usb_register writes[2]; 1279 unsigned int ibsta; 1280 1281 if (!ni_priv->bus_interface) 1282 return -ENODEV; 1283 usb_dev = interface_to_usbdev(ni_priv->bus_interface); 1284 writes[i].device = NIUSB_SUBDEV_TNT4882; 1285 writes[i].address = nec7210_to_tnt4882_offset(ADR); 1286 writes[i].value = address; 1287 i++; 1288 writes[i].device = NIUSB_SUBDEV_UNKNOWN2; 1289 writes[i].address = 0x0; 1290 writes[i].value = address; 1291 i++; 1292 retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta); 1293 if (retval < 0) { 1294 dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval); 1295 return retval; 1296 } 1297 ni_usb_soft_update_status(board, ibsta, 0); 1298 return 0; 1299 } 1300 1301 static int ni_usb_write_sad(struct ni_usb_register *writes, int address, int enable) 1302 { 1303 unsigned int adr_bits, admr_bits; 1304 int i = 0; 1305 1306 adr_bits = HR_ARS; 1307 admr_bits = HR_TRM0 | HR_TRM1; 1308 if (enable) { 1309 adr_bits |= address; 1310 admr_bits |= HR_ADM1; 1311 } else { 1312 adr_bits |= HR_DT | HR_DL; 1313 admr_bits |= HR_ADM0; 1314 } 1315 writes[i].device = NIUSB_SUBDEV_TNT4882; 1316 writes[i].address = nec7210_to_tnt4882_offset(ADR); 1317 writes[i].value = adr_bits; 1318 i++; 1319 writes[i].device = NIUSB_SUBDEV_TNT4882; 1320 writes[i].address = nec7210_to_tnt4882_offset(ADMR); 1321 writes[i].value = admr_bits; 1322 i++; 1323 writes[i].device = NIUSB_SUBDEV_UNKNOWN2; 1324 writes[i].address = 0x1; 1325 writes[i].value = enable ? MSA(address) : 0x0; 1326 i++; 1327 return i; 1328 } 1329 1330 static int ni_usb_secondary_address(struct gpib_board *board, unsigned int address, int enable) 1331 { 1332 int retval; 1333 struct ni_usb_priv *ni_priv = board->private_data; 1334 struct usb_device *usb_dev; 1335 int i = 0; 1336 struct ni_usb_register writes[3]; 1337 unsigned int ibsta; 1338 1339 if (!ni_priv->bus_interface) 1340 return -ENODEV; 1341 usb_dev = interface_to_usbdev(ni_priv->bus_interface); 1342 i += ni_usb_write_sad(writes, address, enable); 1343 retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta); 1344 if (retval < 0) { 1345 dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval); 1346 return retval; 1347 } 1348 ni_usb_soft_update_status(board, ibsta, 0); 1349 return 0; 1350 } 1351 1352 static int ni_usb_parallel_poll(struct gpib_board *board, u8 *result) 1353 { 1354 int retval; 1355 struct ni_usb_priv *ni_priv = board->private_data; 1356 struct usb_device *usb_dev; 1357 u8 *out_data, *in_data; 1358 static const int out_data_length = 0x10; 1359 static const int in_data_length = 0x20; 1360 int bytes_written = 0, bytes_read = 0; 1361 int i = 0; 1362 int j = 0; 1363 struct ni_usb_status_block status; 1364 1365 if (!ni_priv->bus_interface) 1366 return -ENODEV; 1367 usb_dev = interface_to_usbdev(ni_priv->bus_interface); 1368 out_data = kmalloc(out_data_length, GFP_KERNEL); 1369 if (!out_data) 1370 return -ENOMEM; 1371 1372 out_data[i++] = NIUSB_IBRPP_ID; 1373 out_data[i++] = 0xf0; // FIXME: this should be the parallel poll timeout code 1374 out_data[i++] = 0x0; 1375 out_data[i++] = 0x0; 1376 i += ni_usb_bulk_termination(&out_data[i]); 1377 /*FIXME: 1000 should use parallel poll timeout (not supported yet)*/ 1378 retval = ni_usb_send_bulk_msg(ni_priv, out_data, i, &bytes_written, 1000); 1379 1380 kfree(out_data); 1381 if (retval || bytes_written != i) { 1382 dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n", 1383 retval, bytes_written, i); 1384 return retval; 1385 } 1386 in_data = kmalloc(in_data_length, GFP_KERNEL); 1387 if (!in_data) 1388 return -ENOMEM; 1389 1390 /*FIXME: should use parallel poll timeout (not supported yet)*/ 1391 retval = ni_usb_receive_bulk_msg(ni_priv, in_data, in_data_length, 1392 &bytes_read, 1000, 1); 1393 1394 if (retval && retval != -ERESTARTSYS) { 1395 dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n", 1396 retval, bytes_read); 1397 kfree(in_data); 1398 return retval; 1399 } 1400 j += ni_usb_parse_status_block(in_data, &status); 1401 *result = in_data[j++]; 1402 kfree(in_data); 1403 ni_usb_soft_update_status(board, status.ibsta, 0); 1404 return retval; 1405 } 1406 1407 static void ni_usb_parallel_poll_configure(struct gpib_board *board, u8 config) 1408 { 1409 int retval; 1410 struct ni_usb_priv *ni_priv = board->private_data; 1411 struct usb_device *usb_dev; 1412 int i = 0; 1413 struct ni_usb_register writes[1]; 1414 unsigned int ibsta; 1415 1416 if (!ni_priv->bus_interface) 1417 return; // -ENODEV; 1418 usb_dev = interface_to_usbdev(ni_priv->bus_interface); 1419 writes[i].device = NIUSB_SUBDEV_TNT4882; 1420 writes[i].address = nec7210_to_tnt4882_offset(AUXMR); 1421 writes[i].value = PPR | config; 1422 i++; 1423 retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta); 1424 if (retval < 0) { 1425 dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval); 1426 return;// retval; 1427 } 1428 ni_usb_soft_update_status(board, ibsta, 0); 1429 return;// 0; 1430 } 1431 1432 static void ni_usb_parallel_poll_response(struct gpib_board *board, int ist) 1433 { 1434 int retval; 1435 struct ni_usb_priv *ni_priv = board->private_data; 1436 struct usb_device *usb_dev; 1437 int i = 0; 1438 struct ni_usb_register writes[1]; 1439 unsigned int ibsta; 1440 1441 if (!ni_priv->bus_interface) 1442 return; // -ENODEV; 1443 usb_dev = interface_to_usbdev(ni_priv->bus_interface); 1444 writes[i].device = NIUSB_SUBDEV_TNT4882; 1445 writes[i].address = nec7210_to_tnt4882_offset(AUXMR); 1446 if (ist) 1447 writes[i].value = AUX_SPPF; 1448 else 1449 writes[i].value = AUX_CPPF; 1450 i++; 1451 retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta); 1452 if (retval < 0) { 1453 dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval); 1454 return;// retval; 1455 } 1456 ni_usb_soft_update_status(board, ibsta, 0); 1457 return;// 0; 1458 } 1459 1460 static void ni_usb_serial_poll_response(struct gpib_board *board, u8 status) 1461 { 1462 int retval; 1463 struct ni_usb_priv *ni_priv = board->private_data; 1464 struct usb_device *usb_dev; 1465 int i = 0; 1466 struct ni_usb_register writes[1]; 1467 unsigned int ibsta; 1468 1469 if (!ni_priv->bus_interface) 1470 return; // -ENODEV; 1471 usb_dev = interface_to_usbdev(ni_priv->bus_interface); 1472 writes[i].device = NIUSB_SUBDEV_TNT4882; 1473 writes[i].address = nec7210_to_tnt4882_offset(SPMR); 1474 writes[i].value = status; 1475 i++; 1476 retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta); 1477 if (retval < 0) { 1478 dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval); 1479 return;// retval; 1480 } 1481 ni_usb_soft_update_status(board, ibsta, 0); 1482 return;// 0; 1483 } 1484 1485 static u8 ni_usb_serial_poll_status(struct gpib_board *board) 1486 { 1487 return 0; 1488 } 1489 1490 static void ni_usb_return_to_local(struct gpib_board *board) 1491 { 1492 int retval; 1493 struct ni_usb_priv *ni_priv = board->private_data; 1494 struct usb_device *usb_dev; 1495 int i = 0; 1496 struct ni_usb_register writes[1]; 1497 unsigned int ibsta; 1498 1499 if (!ni_priv->bus_interface) 1500 return; // -ENODEV; 1501 usb_dev = interface_to_usbdev(ni_priv->bus_interface); 1502 writes[i].device = NIUSB_SUBDEV_TNT4882; 1503 writes[i].address = nec7210_to_tnt4882_offset(AUXMR); 1504 writes[i].value = AUX_RTL; 1505 i++; 1506 retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta); 1507 if (retval < 0) { 1508 dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval); 1509 return;// retval; 1510 } 1511 ni_usb_soft_update_status(board, ibsta, 0); 1512 return;// 0; 1513 } 1514 1515 static int ni_usb_line_status(const struct gpib_board *board) 1516 { 1517 int retval; 1518 struct ni_usb_priv *ni_priv = board->private_data; 1519 struct usb_device *usb_dev; 1520 u8 *out_data, *in_data; 1521 static const int out_data_length = 0x20; 1522 static const int in_data_length = 0x20; 1523 int bytes_written = 0, bytes_read = 0; 1524 int i = 0; 1525 unsigned int bsr_bits; 1526 int line_status = VALID_ALL; 1527 // NI windows driver reads 0xd(HSSEL), 0xc (ARD0), 0x1f (BSR) 1528 1529 if (!ni_priv->bus_interface) 1530 return -ENODEV; 1531 usb_dev = interface_to_usbdev(ni_priv->bus_interface); 1532 out_data = kmalloc(out_data_length, GFP_KERNEL); 1533 if (!out_data) 1534 return -ENOMEM; 1535 1536 /* line status gets called during ibwait */ 1537 retval = mutex_trylock(&ni_priv->addressed_transfer_lock); 1538 1539 if (retval == 0) { 1540 kfree(out_data); 1541 return -EBUSY; 1542 } 1543 i += ni_usb_bulk_register_read_header(&out_data[i], 1); 1544 i += ni_usb_bulk_register_read(&out_data[i], NIUSB_SUBDEV_TNT4882, BSR); 1545 while (i % 4) 1546 out_data[i++] = 0x0; 1547 i += ni_usb_bulk_termination(&out_data[i]); 1548 retval = ni_usb_nonblocking_send_bulk_msg(ni_priv, out_data, i, &bytes_written, 1000); 1549 kfree(out_data); 1550 if (retval || bytes_written != i) { 1551 mutex_unlock(&ni_priv->addressed_transfer_lock); 1552 if (retval != -EAGAIN) 1553 dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n", 1554 retval, bytes_written, i); 1555 return retval; 1556 } 1557 1558 in_data = kmalloc(in_data_length, GFP_KERNEL); 1559 if (!in_data) { 1560 mutex_unlock(&ni_priv->addressed_transfer_lock); 1561 return -ENOMEM; 1562 } 1563 retval = ni_usb_nonblocking_receive_bulk_msg(ni_priv, in_data, in_data_length, 1564 &bytes_read, 1000, 0); 1565 1566 mutex_unlock(&ni_priv->addressed_transfer_lock); 1567 1568 if (retval) { 1569 if (retval != -EAGAIN) 1570 dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n", 1571 retval, bytes_read); 1572 kfree(in_data); 1573 return retval; 1574 } 1575 1576 ni_usb_parse_register_read_block(in_data, &bsr_bits, 1); 1577 kfree(in_data); 1578 if (bsr_bits & BCSR_REN_BIT) 1579 line_status |= BUS_REN; 1580 if (bsr_bits & BCSR_IFC_BIT) 1581 line_status |= BUS_IFC; 1582 if (bsr_bits & BCSR_SRQ_BIT) 1583 line_status |= BUS_SRQ; 1584 if (bsr_bits & BCSR_EOI_BIT) 1585 line_status |= BUS_EOI; 1586 if (bsr_bits & BCSR_NRFD_BIT) 1587 line_status |= BUS_NRFD; 1588 if (bsr_bits & BCSR_NDAC_BIT) 1589 line_status |= BUS_NDAC; 1590 if (bsr_bits & BCSR_DAV_BIT) 1591 line_status |= BUS_DAV; 1592 if (bsr_bits & BCSR_ATN_BIT) 1593 line_status |= BUS_ATN; 1594 return line_status; 1595 } 1596 1597 static int ni_usb_setup_t1_delay(struct ni_usb_register *reg, unsigned int nano_sec, 1598 unsigned int *actual_ns) 1599 { 1600 int i = 0; 1601 1602 *actual_ns = 2000; 1603 1604 reg[i].device = NIUSB_SUBDEV_TNT4882; 1605 reg[i].address = nec7210_to_tnt4882_offset(AUXMR); 1606 if (nano_sec <= 1100) { 1607 reg[i].value = AUXRI | USTD | SISB; 1608 *actual_ns = 1100; 1609 } else { 1610 reg[i].value = AUXRI | SISB; 1611 } 1612 i++; 1613 reg[i].device = NIUSB_SUBDEV_TNT4882; 1614 reg[i].address = nec7210_to_tnt4882_offset(AUXMR); 1615 if (nano_sec <= 500) { 1616 reg[i].value = AUXRB | HR_TRI; 1617 *actual_ns = 500; 1618 } else { 1619 reg[i].value = AUXRB; 1620 } 1621 i++; 1622 reg[i].device = NIUSB_SUBDEV_TNT4882; 1623 reg[i].address = KEYREG; 1624 if (nano_sec <= 350) { 1625 reg[i].value = MSTD; 1626 *actual_ns = 350; 1627 } else { 1628 reg[i].value = 0x0; 1629 } 1630 i++; 1631 return i; 1632 } 1633 1634 static int ni_usb_t1_delay(struct gpib_board *board, unsigned int nano_sec) 1635 { 1636 int retval; 1637 struct ni_usb_priv *ni_priv = board->private_data; 1638 struct usb_device *usb_dev; 1639 struct ni_usb_register writes[3]; 1640 unsigned int ibsta; 1641 unsigned int actual_ns; 1642 int i; 1643 1644 if (!ni_priv->bus_interface) 1645 return -ENODEV; 1646 usb_dev = interface_to_usbdev(ni_priv->bus_interface); 1647 i = ni_usb_setup_t1_delay(writes, nano_sec, &actual_ns); 1648 retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta); 1649 if (retval < 0) { 1650 dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval); 1651 return retval; 1652 } 1653 board->t1_nano_sec = actual_ns; 1654 ni_usb_soft_update_status(board, ibsta, 0); 1655 return actual_ns; 1656 } 1657 1658 static int ni_usb_allocate_private(struct gpib_board *board) 1659 { 1660 struct ni_usb_priv *ni_priv; 1661 1662 board->private_data = kmalloc(sizeof(struct ni_usb_priv), GFP_KERNEL); 1663 if (!board->private_data) 1664 return -ENOMEM; 1665 ni_priv = board->private_data; 1666 memset(ni_priv, 0, sizeof(struct ni_usb_priv)); 1667 mutex_init(&ni_priv->bulk_transfer_lock); 1668 mutex_init(&ni_priv->control_transfer_lock); 1669 mutex_init(&ni_priv->interrupt_transfer_lock); 1670 mutex_init(&ni_priv->addressed_transfer_lock); 1671 return 0; 1672 } 1673 1674 static void ni_usb_free_private(struct ni_usb_priv *ni_priv) 1675 { 1676 usb_free_urb(ni_priv->interrupt_urb); 1677 kfree(ni_priv); 1678 } 1679 1680 #define NUM_INIT_WRITES 26 1681 static int ni_usb_setup_init(struct gpib_board *board, struct ni_usb_register *writes) 1682 { 1683 struct ni_usb_priv *ni_priv = board->private_data; 1684 struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); 1685 unsigned int mask, actual_ns; 1686 int i = 0; 1687 1688 writes[i].device = NIUSB_SUBDEV_UNKNOWN3; 1689 writes[i].address = 0x10; 1690 writes[i].value = 0x0; 1691 i++; 1692 writes[i].device = NIUSB_SUBDEV_TNT4882; 1693 writes[i].address = CMDR; 1694 writes[i].value = SOFT_RESET; 1695 i++; 1696 writes[i].device = NIUSB_SUBDEV_TNT4882; 1697 writes[i].address = nec7210_to_tnt4882_offset(AUXMR); 1698 mask = AUXRA | HR_HLDA; 1699 if (ni_priv->eos_mode & BIN) 1700 mask |= HR_BIN; 1701 writes[i].value = mask; 1702 i++; 1703 writes[i].device = NIUSB_SUBDEV_TNT4882; 1704 writes[i].address = AUXCR; 1705 writes[i].value = mask; 1706 i++; 1707 writes[i].device = NIUSB_SUBDEV_TNT4882; 1708 writes[i].address = HSSEL; 1709 writes[i].value = TNT_ONE_CHIP_BIT; 1710 i++; 1711 writes[i].device = NIUSB_SUBDEV_TNT4882; 1712 writes[i].address = nec7210_to_tnt4882_offset(AUXMR); 1713 writes[i].value = AUX_CR; 1714 i++; 1715 writes[i].device = NIUSB_SUBDEV_TNT4882; 1716 writes[i].address = IMR0; 1717 writes[i].value = TNT_IMR0_ALWAYS_BITS; 1718 i++; 1719 writes[i].device = NIUSB_SUBDEV_TNT4882; 1720 writes[i].address = nec7210_to_tnt4882_offset(IMR1); 1721 writes[i].value = 0x0; 1722 i++; 1723 writes[i].device = NIUSB_SUBDEV_TNT4882; 1724 writes[i].address = nec7210_to_tnt4882_offset(IMR2); 1725 writes[i].value = 0x0; 1726 i++; 1727 writes[i].device = NIUSB_SUBDEV_TNT4882; 1728 writes[i].address = IMR3; 1729 writes[i].value = 0x0; 1730 i++; 1731 writes[i].device = NIUSB_SUBDEV_TNT4882; 1732 writes[i].address = nec7210_to_tnt4882_offset(AUXMR); 1733 writes[i].value = AUX_HLDI; 1734 i++; 1735 1736 i += ni_usb_setup_t1_delay(&writes[i], board->t1_nano_sec, &actual_ns); 1737 1738 writes[i].device = NIUSB_SUBDEV_TNT4882; 1739 writes[i].address = nec7210_to_tnt4882_offset(AUXMR); 1740 writes[i].value = AUXRG | NTNL_BIT; 1741 i++; 1742 writes[i].device = NIUSB_SUBDEV_TNT4882; 1743 writes[i].address = CMDR; 1744 if (board->master) 1745 mask = SETSC; // set system controller 1746 else 1747 mask = CLRSC; // clear system controller 1748 writes[i].value = mask; 1749 i++; 1750 writes[i].device = NIUSB_SUBDEV_TNT4882; 1751 writes[i].address = nec7210_to_tnt4882_offset(AUXMR); 1752 writes[i].value = AUX_CIFC; 1753 i++; 1754 writes[i].device = NIUSB_SUBDEV_TNT4882; 1755 writes[i].address = nec7210_to_tnt4882_offset(ADR); 1756 writes[i].value = board->pad; 1757 i++; 1758 writes[i].device = NIUSB_SUBDEV_UNKNOWN2; 1759 writes[i].address = 0x0; 1760 writes[i].value = board->pad; 1761 i++; 1762 1763 i += ni_usb_write_sad(&writes[i], board->sad, board->sad >= 0); 1764 1765 writes[i].device = NIUSB_SUBDEV_UNKNOWN2; 1766 writes[i].address = 0x2; // could this be a timeout ? 1767 writes[i].value = 0xfd; 1768 i++; 1769 writes[i].device = NIUSB_SUBDEV_TNT4882; 1770 writes[i].address = 0xf; // undocumented address 1771 writes[i].value = 0x11; 1772 i++; 1773 writes[i].device = NIUSB_SUBDEV_TNT4882; 1774 writes[i].address = nec7210_to_tnt4882_offset(AUXMR); 1775 writes[i].value = AUX_PON; 1776 i++; 1777 writes[i].device = NIUSB_SUBDEV_TNT4882; 1778 writes[i].address = nec7210_to_tnt4882_offset(AUXMR); 1779 writes[i].value = AUX_CPPF; 1780 i++; 1781 if (i > NUM_INIT_WRITES) { 1782 dev_err(&usb_dev->dev, "bug!, buffer overrun, i=%i\n", i); 1783 return 0; 1784 } 1785 return i; 1786 } 1787 1788 static int ni_usb_init(struct gpib_board *board) 1789 { 1790 int retval; 1791 struct ni_usb_priv *ni_priv = board->private_data; 1792 struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); 1793 struct ni_usb_register *writes; 1794 unsigned int ibsta; 1795 int writes_len; 1796 1797 writes = kmalloc_array(NUM_INIT_WRITES, sizeof(*writes), GFP_KERNEL); 1798 if (!writes) 1799 return -ENOMEM; 1800 1801 writes_len = ni_usb_setup_init(board, writes); 1802 if (writes_len) 1803 retval = ni_usb_write_registers(ni_priv, writes, writes_len, &ibsta); 1804 else 1805 return -EFAULT; 1806 kfree(writes); 1807 if (retval) { 1808 dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval); 1809 return retval; 1810 } 1811 ni_usb_soft_update_status(board, ibsta, 0); 1812 return 0; 1813 } 1814 1815 static void ni_usb_interrupt_complete(struct urb *urb) 1816 { 1817 struct gpib_board *board = urb->context; 1818 struct ni_usb_priv *ni_priv = board->private_data; 1819 struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); 1820 int retval; 1821 struct ni_usb_status_block status; 1822 unsigned long flags; 1823 1824 switch (urb->status) { 1825 /* success */ 1826 case 0: 1827 break; 1828 /* unlinked, don't resubmit */ 1829 case -ECONNRESET: 1830 case -ENOENT: 1831 case -ESHUTDOWN: 1832 return; 1833 default: /* other error, resubmit */ 1834 retval = usb_submit_urb(ni_priv->interrupt_urb, GFP_ATOMIC); 1835 if (retval) 1836 dev_err(&usb_dev->dev, "failed to resubmit interrupt urb\n"); 1837 return; 1838 } 1839 1840 ni_usb_parse_status_block(urb->transfer_buffer, &status); 1841 1842 spin_lock_irqsave(&board->spinlock, flags); 1843 ni_priv->monitored_ibsta_bits &= ~status.ibsta; 1844 spin_unlock_irqrestore(&board->spinlock, flags); 1845 1846 wake_up_interruptible(&board->wait); 1847 1848 retval = usb_submit_urb(ni_priv->interrupt_urb, GFP_ATOMIC); 1849 if (retval) 1850 dev_err(&usb_dev->dev, "failed to resubmit interrupt urb\n"); 1851 } 1852 1853 static int ni_usb_set_interrupt_monitor(struct gpib_board *board, unsigned int monitored_bits) 1854 { 1855 int retval; 1856 struct ni_usb_priv *ni_priv = board->private_data; 1857 struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); 1858 static const int buffer_length = 8; 1859 u8 *buffer; 1860 struct ni_usb_status_block status; 1861 unsigned long flags; 1862 1863 buffer = kmalloc(buffer_length, GFP_KERNEL); 1864 if (!buffer) 1865 return -ENOMEM; 1866 1867 spin_lock_irqsave(&board->spinlock, flags); 1868 ni_priv->monitored_ibsta_bits = ni_usb_ibsta_monitor_mask & monitored_bits; 1869 spin_unlock_irqrestore(&board->spinlock, flags); 1870 retval = ni_usb_receive_control_msg(ni_priv, NI_USB_WAIT_REQUEST, USB_DIR_IN | 1871 USB_TYPE_VENDOR | USB_RECIP_DEVICE, 1872 0x300, ni_usb_ibsta_monitor_mask & monitored_bits, 1873 buffer, buffer_length, 1000); 1874 if (retval != buffer_length) { 1875 dev_err(&usb_dev->dev, "usb_control_msg returned %i\n", retval); 1876 kfree(buffer); 1877 return -1; 1878 } 1879 ni_usb_parse_status_block(buffer, &status); 1880 kfree(buffer); 1881 return 0; 1882 } 1883 1884 static int ni_usb_setup_urbs(struct gpib_board *board) 1885 { 1886 struct ni_usb_priv *ni_priv = board->private_data; 1887 struct usb_device *usb_dev; 1888 int int_pipe; 1889 int retval; 1890 1891 if (ni_priv->interrupt_in_endpoint < 0) 1892 return 0; 1893 1894 mutex_lock(&ni_priv->interrupt_transfer_lock); 1895 if (!ni_priv->bus_interface) { 1896 mutex_unlock(&ni_priv->interrupt_transfer_lock); 1897 return -ENODEV; 1898 } 1899 ni_priv->interrupt_urb = usb_alloc_urb(0, GFP_KERNEL); 1900 if (!ni_priv->interrupt_urb) { 1901 mutex_unlock(&ni_priv->interrupt_transfer_lock); 1902 return -ENOMEM; 1903 } 1904 usb_dev = interface_to_usbdev(ni_priv->bus_interface); 1905 int_pipe = usb_rcvintpipe(usb_dev, ni_priv->interrupt_in_endpoint); 1906 usb_fill_int_urb(ni_priv->interrupt_urb, usb_dev, int_pipe, ni_priv->interrupt_buffer, 1907 sizeof(ni_priv->interrupt_buffer), &ni_usb_interrupt_complete, board, 1); 1908 retval = usb_submit_urb(ni_priv->interrupt_urb, GFP_KERNEL); 1909 mutex_unlock(&ni_priv->interrupt_transfer_lock); 1910 if (retval) { 1911 dev_err(&usb_dev->dev, "failed to submit first interrupt urb, retval=%i\n", retval); 1912 return retval; 1913 } 1914 return 0; 1915 } 1916 1917 static void ni_usb_cleanup_urbs(struct ni_usb_priv *ni_priv) 1918 { 1919 if (ni_priv && ni_priv->bus_interface) { 1920 if (ni_priv->interrupt_urb) 1921 usb_kill_urb(ni_priv->interrupt_urb); 1922 if (ni_priv->bulk_urb) 1923 usb_kill_urb(ni_priv->bulk_urb); 1924 } 1925 } 1926 1927 static int ni_usb_b_read_serial_number(struct ni_usb_priv *ni_priv) 1928 { 1929 struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); 1930 int retval; 1931 u8 *out_data; 1932 u8 *in_data; 1933 static const int out_data_length = 0x20; 1934 static const int in_data_length = 0x20; 1935 int bytes_written = 0, bytes_read = 0; 1936 int i = 0; 1937 static const int num_reads = 4; 1938 unsigned int results[4]; 1939 int j; 1940 unsigned int serial_number; 1941 1942 in_data = kmalloc(in_data_length, GFP_KERNEL); 1943 if (!in_data) 1944 return -ENOMEM; 1945 1946 out_data = kmalloc(out_data_length, GFP_KERNEL); 1947 if (!out_data) { 1948 kfree(in_data); 1949 return -ENOMEM; 1950 } 1951 i += ni_usb_bulk_register_read_header(&out_data[i], num_reads); 1952 i += ni_usb_bulk_register_read(&out_data[i], NIUSB_SUBDEV_UNKNOWN3, SERIAL_NUMBER_1_REG); 1953 i += ni_usb_bulk_register_read(&out_data[i], NIUSB_SUBDEV_UNKNOWN3, SERIAL_NUMBER_2_REG); 1954 i += ni_usb_bulk_register_read(&out_data[i], NIUSB_SUBDEV_UNKNOWN3, SERIAL_NUMBER_3_REG); 1955 i += ni_usb_bulk_register_read(&out_data[i], NIUSB_SUBDEV_UNKNOWN3, SERIAL_NUMBER_4_REG); 1956 while (i % 4) 1957 out_data[i++] = 0x0; 1958 i += ni_usb_bulk_termination(&out_data[i]); 1959 retval = ni_usb_send_bulk_msg(ni_priv, out_data, out_data_length, &bytes_written, 1000); 1960 if (retval) { 1961 dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%li\n", 1962 retval, bytes_written, (long)out_data_length); 1963 goto serial_out; 1964 } 1965 retval = ni_usb_receive_bulk_msg(ni_priv, in_data, in_data_length, &bytes_read, 1000, 0); 1966 if (retval) { 1967 dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n", 1968 retval, bytes_read); 1969 ni_usb_dump_raw_block(in_data, bytes_read); 1970 goto serial_out; 1971 } 1972 if (ARRAY_SIZE(results) < num_reads) { 1973 dev_err(&usb_dev->dev, "serial number eetup bug\n"); 1974 retval = -EINVAL; 1975 goto serial_out; 1976 } 1977 ni_usb_parse_register_read_block(in_data, results, num_reads); 1978 serial_number = 0; 1979 for (j = 0; j < num_reads; ++j) 1980 serial_number |= (results[j] & 0xff) << (8 * j); 1981 dev_dbg(&usb_dev->dev, "board serial number is 0x%x\n", serial_number); 1982 retval = 0; 1983 serial_out: 1984 kfree(in_data); 1985 kfree(out_data); 1986 return retval; 1987 } 1988 1989 static int ni_usb_hs_wait_for_ready(struct ni_usb_priv *ni_priv) 1990 { 1991 struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); 1992 static const int buffer_size = 0x10; 1993 static const int timeout = 50; 1994 static const int msec_sleep_duration = 100; 1995 int i; int retval; 1996 int j; 1997 int unexpected = 0; 1998 unsigned int serial_number; 1999 u8 *buffer; 2000 2001 buffer = kmalloc(buffer_size, GFP_KERNEL); 2002 if (!buffer) 2003 return -ENOMEM; 2004 2005 retval = ni_usb_receive_control_msg(ni_priv, NI_USB_SERIAL_NUMBER_REQUEST, 2006 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 2007 0x0, 0x0, buffer, buffer_size, 1000); 2008 if (retval < 0) { 2009 dev_err(&usb_dev->dev, "usb_control_msg request 0x%x returned %i\n", 2010 NI_USB_SERIAL_NUMBER_REQUEST, retval); 2011 goto ready_out; 2012 } 2013 j = 0; 2014 if (buffer[j] != NI_USB_SERIAL_NUMBER_REQUEST) { 2015 dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x%x\n", 2016 j, (int)buffer[j], NI_USB_SERIAL_NUMBER_REQUEST); 2017 unexpected = 1; 2018 } 2019 if (unexpected) 2020 ni_usb_dump_raw_block(buffer, retval); 2021 // NI-USB-HS+ pads the serial with 0x0 to make 16 bytes 2022 if (retval != 5 && retval != 16) { 2023 dev_err(&usb_dev->dev, "received unexpected number of bytes = %i, expected 5 or 16\n", 2024 retval); 2025 ni_usb_dump_raw_block(buffer, retval); 2026 } 2027 serial_number = 0; 2028 serial_number |= buffer[++j]; 2029 serial_number |= (buffer[++j] << 8); 2030 serial_number |= (buffer[++j] << 16); 2031 serial_number |= (buffer[++j] << 24); 2032 dev_dbg(&usb_dev->dev, "board serial number is 0x%x\n", serial_number); 2033 for (i = 0; i < timeout; ++i) { 2034 int ready = 0; 2035 2036 retval = ni_usb_receive_control_msg(ni_priv, NI_USB_POLL_READY_REQUEST, 2037 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 2038 0x0, 0x0, buffer, buffer_size, 100); 2039 if (retval < 0) { 2040 dev_err(&usb_dev->dev, "usb_control_msg request 0x%x returned %i\n", 2041 NI_USB_POLL_READY_REQUEST, retval); 2042 goto ready_out; 2043 } 2044 j = 0; 2045 unexpected = 0; 2046 if (buffer[j] != NI_USB_POLL_READY_REQUEST) { // [0] 2047 dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x%x\n", 2048 j, (int)buffer[j], NI_USB_POLL_READY_REQUEST); 2049 unexpected = 1; 2050 } 2051 ++j; 2052 if (buffer[j] != 0x1 && buffer[j] != 0x0) { // [1] HS+ sends 0x0 2053 dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x1 or 0x0\n", 2054 j, (int)buffer[j]); 2055 unexpected = 1; 2056 } 2057 if (buffer[++j] != 0x0) { // [2] 2058 dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x%x\n", 2059 j, (int)buffer[j], 0x0); 2060 unexpected = 1; 2061 } 2062 ++j; 2063 /* 2064 * MC usb-488 (and sometimes NI-USB-HS?) sends 0x8 here; MC usb-488A sends 0x7 here 2065 * NI-USB-HS+ sends 0x0 2066 */ 2067 if (buffer[j] != 0x1 && buffer[j] != 0x8 && buffer[j] != 0x7 && buffer[j] != 0x0) { 2068 // [3] 2069 dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x0, 0x1, 0x7 or 0x8\n", 2070 j, (int)buffer[j]); 2071 unexpected = 1; 2072 } 2073 ++j; 2074 // NI-USB-HS+ sends 0 here 2075 if (buffer[j] != 0x30 && buffer[j] != 0x0) { // [4] 2076 dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x0 or 0x30\n", 2077 j, (int)buffer[j]); 2078 unexpected = 1; 2079 } 2080 ++j; 2081 // MC usb-488 (and sometimes NI-USB-HS?) and NI-USB-HS+ sends 0x0 here 2082 if (buffer[j] != 0x1 && buffer[j] != 0x0) { // [5] 2083 dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x1 or 0x0\n", 2084 j, (int)buffer[j]); 2085 unexpected = 1; 2086 } 2087 if (buffer[++j] != 0x0) { // [6] 2088 ready = 1; 2089 // NI-USB-HS+ sends 0xf or 0x19 here 2090 if (buffer[j] != 0x2 && buffer[j] != 0xe && buffer[j] != 0xf && 2091 buffer[j] != 0x16 && buffer[j] != 0x19) { 2092 dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x2, 0xe, 0xf, 0x16 or 0x19\n", 2093 j, (int)buffer[j]); 2094 unexpected = 1; 2095 } 2096 } 2097 if (buffer[++j] != 0x0) { // [7] 2098 ready = 1; 2099 // MC usb-488 sends 0x5 here; MC usb-488A sends 0x6 here 2100 if (buffer[j] != 0x3 && buffer[j] != 0x5 && buffer[j] != 0x6 && 2101 buffer[j] != 0x8) { 2102 dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x3 or 0x5, 0x6 or 0x08\n", 2103 j, (int)buffer[j]); 2104 unexpected = 1; 2105 } 2106 } 2107 ++j; 2108 if (buffer[j] != 0x0 && buffer[j] != 0x2) { // [8] MC usb-488 sends 0x2 here 2109 dev_err(&usb_dev->dev, " unexpected data: buffer[%i]=0x%x, expected 0x0 or 0x2\n", 2110 j, (int)buffer[j]); 2111 unexpected = 1; 2112 } 2113 ++j; 2114 // MC usb-488A and NI-USB-HS sends 0x3 here; NI-USB-HS+ sends 0x30 here 2115 if (buffer[j] != 0x0 && buffer[j] != 0x3 && buffer[j] != 0x30) { // [9] 2116 dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x0, 0x3 or 0x30\n", 2117 j, (int)buffer[j]); 2118 unexpected = 1; 2119 } 2120 if (buffer[++j] != 0x0) { // [10] MC usb-488 sends 0x7 here, new HS+ sends 0x59 2121 ready = 1; 2122 if (buffer[j] != 0x96 && buffer[j] != 0x7 && buffer[j] != 0x6e && 2123 buffer[j] != 0x59) { 2124 dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x96, 0x07, 0x6e or 0x59\n", 2125 j, (int)buffer[j]); 2126 unexpected = 1; 2127 } 2128 } 2129 if (unexpected) 2130 ni_usb_dump_raw_block(buffer, retval); 2131 if (ready) 2132 break; 2133 retval = msleep_interruptible(msec_sleep_duration); 2134 if (retval) { 2135 retval = -ERESTARTSYS; 2136 goto ready_out; 2137 } 2138 } 2139 retval = 0; 2140 2141 ready_out: 2142 kfree(buffer); 2143 dev_dbg(&usb_dev->dev, "exit retval=%d\n", retval); 2144 return retval; 2145 } 2146 2147 /* 2148 * This does some extra init for HS+ models, as observed on Windows. One of the 2149 * control requests causes the LED to stop blinking. 2150 * I'm not sure what the other 2 requests do. None of these requests are actually required 2151 * for the adapter to work, maybe they do some init for the analyzer interface 2152 * (which we don't use). 2153 */ 2154 static int ni_usb_hs_plus_extra_init(struct ni_usb_priv *ni_priv) 2155 { 2156 struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); 2157 int retval; 2158 u8 *buffer; 2159 static const int buffer_size = 16; 2160 int transfer_size; 2161 2162 buffer = kmalloc(buffer_size, GFP_KERNEL); 2163 if (!buffer) 2164 return -ENOMEM; 2165 do { 2166 transfer_size = 16; 2167 2168 retval = ni_usb_receive_control_msg(ni_priv, NI_USB_HS_PLUS_0x48_REQUEST, 2169 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 2170 0x0, 0x0, buffer, transfer_size, 1000); 2171 if (retval < 0) { 2172 dev_err(&usb_dev->dev, "usb_control_msg request 0x%x returned %i\n", 2173 NI_USB_HS_PLUS_0x48_REQUEST, retval); 2174 break; 2175 } 2176 // expected response data: 48 f3 30 00 00 00 00 00 00 00 00 00 00 00 00 00 2177 if (buffer[0] != NI_USB_HS_PLUS_0x48_REQUEST) 2178 dev_err(&usb_dev->dev, "unexpected data: buffer[0]=0x%x, expected 0x%x\n", 2179 (int)buffer[0], NI_USB_HS_PLUS_0x48_REQUEST); 2180 2181 transfer_size = 2; 2182 2183 retval = ni_usb_receive_control_msg(ni_priv, NI_USB_HS_PLUS_LED_REQUEST, 2184 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 2185 0x1, 0x0, buffer, transfer_size, 1000); 2186 if (retval < 0) { 2187 dev_err(&usb_dev->dev, "usb_control_msg request 0x%x returned %i\n", 2188 NI_USB_HS_PLUS_LED_REQUEST, retval); 2189 break; 2190 } 2191 // expected response data: 4b 00 2192 if (buffer[0] != NI_USB_HS_PLUS_LED_REQUEST) 2193 dev_err(&usb_dev->dev, "unexpected data: buffer[0]=0x%x, expected 0x%x\n", 2194 (int)buffer[0], NI_USB_HS_PLUS_LED_REQUEST); 2195 2196 transfer_size = 9; 2197 2198 retval = ni_usb_receive_control_msg(ni_priv, NI_USB_HS_PLUS_0xf8_REQUEST, 2199 USB_DIR_IN | USB_TYPE_VENDOR | 2200 USB_RECIP_INTERFACE, 2201 0x0, 0x1, buffer, transfer_size, 1000); 2202 if (retval < 0) { 2203 dev_err(&usb_dev->dev, "usb_control_msg request 0x%x returned %i\n", 2204 NI_USB_HS_PLUS_0xf8_REQUEST, retval); 2205 break; 2206 } 2207 // expected response data: f8 01 00 00 00 01 00 00 00 2208 if (buffer[0] != NI_USB_HS_PLUS_0xf8_REQUEST) 2209 dev_err(&usb_dev->dev, "unexpected data: buffer[0]=0x%x, expected 0x%x\n", 2210 (int)buffer[0], NI_USB_HS_PLUS_0xf8_REQUEST); 2211 } while (0); 2212 2213 // cleanup 2214 kfree(buffer); 2215 return retval; 2216 } 2217 2218 static inline int ni_usb_device_match(struct usb_interface *interface, 2219 const struct gpib_board_config *config) 2220 { 2221 if (gpib_match_device_path(&interface->dev, config->device_path) == 0) 2222 return 0; 2223 return 1; 2224 } 2225 2226 static int ni_usb_attach(struct gpib_board *board, const struct gpib_board_config *config) 2227 { 2228 int retval; 2229 int i, index; 2230 struct ni_usb_priv *ni_priv; 2231 int product_id; 2232 struct usb_device *usb_dev; 2233 2234 mutex_lock(&ni_usb_hotplug_lock); 2235 retval = ni_usb_allocate_private(board); 2236 if (retval < 0) { 2237 mutex_unlock(&ni_usb_hotplug_lock); 2238 return retval; 2239 } 2240 ni_priv = board->private_data; 2241 for (i = 0; i < MAX_NUM_NI_USB_INTERFACES; i++) { 2242 if (ni_usb_driver_interfaces[i] && 2243 !usb_get_intfdata(ni_usb_driver_interfaces[i]) && 2244 ni_usb_device_match(ni_usb_driver_interfaces[i], config)) { 2245 ni_priv->bus_interface = ni_usb_driver_interfaces[i]; 2246 usb_set_intfdata(ni_usb_driver_interfaces[i], board); 2247 usb_dev = interface_to_usbdev(ni_priv->bus_interface); 2248 index = i; 2249 break; 2250 } 2251 } 2252 if (i == MAX_NUM_NI_USB_INTERFACES) { 2253 mutex_unlock(&ni_usb_hotplug_lock); 2254 dev_err(board->gpib_dev, "No supported adapters found, have you loaded its firmware?\n"); 2255 return -ENODEV; 2256 } 2257 if (usb_reset_configuration(interface_to_usbdev(ni_priv->bus_interface))) 2258 dev_err(&usb_dev->dev, "usb_reset_configuration() failed.\n"); 2259 2260 product_id = le16_to_cpu(usb_dev->descriptor.idProduct); 2261 ni_priv->product_id = product_id; 2262 2263 timer_setup(&ni_priv->bulk_timer, ni_usb_timeout_handler, 0); 2264 2265 switch (product_id) { 2266 case USB_DEVICE_ID_NI_USB_B: 2267 ni_priv->bulk_out_endpoint = NIUSB_B_BULK_OUT_ENDPOINT; 2268 ni_priv->bulk_in_endpoint = NIUSB_B_BULK_IN_ENDPOINT; 2269 ni_priv->interrupt_in_endpoint = NIUSB_B_INTERRUPT_IN_ENDPOINT; 2270 ni_usb_b_read_serial_number(ni_priv); 2271 break; 2272 case USB_DEVICE_ID_NI_USB_HS: 2273 case USB_DEVICE_ID_MC_USB_488: 2274 case USB_DEVICE_ID_KUSB_488A: 2275 ni_priv->bulk_out_endpoint = NIUSB_HS_BULK_OUT_ENDPOINT; 2276 ni_priv->bulk_in_endpoint = NIUSB_HS_BULK_IN_ENDPOINT; 2277 ni_priv->interrupt_in_endpoint = NIUSB_HS_INTERRUPT_IN_ENDPOINT; 2278 retval = ni_usb_hs_wait_for_ready(ni_priv); 2279 if (retval < 0) { 2280 mutex_unlock(&ni_usb_hotplug_lock); 2281 return retval; 2282 } 2283 break; 2284 case USB_DEVICE_ID_NI_USB_HS_PLUS: 2285 ni_priv->bulk_out_endpoint = NIUSB_HS_PLUS_BULK_OUT_ENDPOINT; 2286 ni_priv->bulk_in_endpoint = NIUSB_HS_PLUS_BULK_IN_ENDPOINT; 2287 ni_priv->interrupt_in_endpoint = NIUSB_HS_PLUS_INTERRUPT_IN_ENDPOINT; 2288 retval = ni_usb_hs_wait_for_ready(ni_priv); 2289 if (retval < 0) { 2290 mutex_unlock(&ni_usb_hotplug_lock); 2291 return retval; 2292 } 2293 retval = ni_usb_hs_plus_extra_init(ni_priv); 2294 if (retval < 0) { 2295 mutex_unlock(&ni_usb_hotplug_lock); 2296 return retval; 2297 } 2298 break; 2299 default: 2300 mutex_unlock(&ni_usb_hotplug_lock); 2301 dev_err(&usb_dev->dev, "\tDriver bug: unknown endpoints for usb device id %x\n", 2302 product_id); 2303 return -EINVAL; 2304 } 2305 2306 retval = ni_usb_setup_urbs(board); 2307 if (retval < 0) { 2308 mutex_unlock(&ni_usb_hotplug_lock); 2309 return retval; 2310 } 2311 retval = ni_usb_set_interrupt_monitor(board, 0); 2312 if (retval < 0) { 2313 mutex_unlock(&ni_usb_hotplug_lock); 2314 return retval; 2315 } 2316 2317 board->t1_nano_sec = 500; 2318 2319 retval = ni_usb_init(board); 2320 if (retval < 0) { 2321 mutex_unlock(&ni_usb_hotplug_lock); 2322 return retval; 2323 } 2324 retval = ni_usb_set_interrupt_monitor(board, ni_usb_ibsta_monitor_mask); 2325 if (retval < 0) { 2326 mutex_unlock(&ni_usb_hotplug_lock); 2327 return retval; 2328 } 2329 2330 mutex_unlock(&ni_usb_hotplug_lock); 2331 dev_info(&usb_dev->dev, 2332 "bus %d dev num %d attached to gpib%d, intf %i\n", 2333 usb_dev->bus->busnum, usb_dev->devnum, board->minor, index); 2334 return retval; 2335 } 2336 2337 static int ni_usb_shutdown_hardware(struct ni_usb_priv *ni_priv) 2338 { 2339 struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); 2340 int retval; 2341 struct ni_usb_register writes[2]; 2342 static const int writes_length = ARRAY_SIZE(writes); 2343 unsigned int ibsta; 2344 2345 writes[0].device = NIUSB_SUBDEV_TNT4882; 2346 writes[0].address = nec7210_to_tnt4882_offset(AUXMR); 2347 writes[0].value = AUX_CR; 2348 writes[1].device = NIUSB_SUBDEV_UNKNOWN3; 2349 writes[1].address = 0x10; 2350 writes[1].value = 0x0; 2351 retval = ni_usb_write_registers(ni_priv, writes, writes_length, &ibsta); 2352 if (retval) { 2353 dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval); 2354 return retval; 2355 } 2356 return 0; 2357 } 2358 2359 static void ni_usb_detach(struct gpib_board *board) 2360 { 2361 struct ni_usb_priv *ni_priv; 2362 2363 mutex_lock(&ni_usb_hotplug_lock); 2364 /* 2365 * under windows, software unplug does chip_reset nec7210 aux command, 2366 * then writes 0x0 to address 0x10 of device 3 2367 */ 2368 ni_priv = board->private_data; 2369 if (ni_priv) { 2370 if (ni_priv->bus_interface) { 2371 ni_usb_set_interrupt_monitor(board, 0); 2372 ni_usb_shutdown_hardware(ni_priv); 2373 usb_set_intfdata(ni_priv->bus_interface, NULL); 2374 } 2375 mutex_lock(&ni_priv->bulk_transfer_lock); 2376 mutex_lock(&ni_priv->control_transfer_lock); 2377 mutex_lock(&ni_priv->interrupt_transfer_lock); 2378 ni_usb_cleanup_urbs(ni_priv); 2379 ni_usb_free_private(ni_priv); 2380 } 2381 mutex_unlock(&ni_usb_hotplug_lock); 2382 } 2383 2384 static struct gpib_interface ni_usb_gpib_interface = { 2385 .name = "ni_usb_b", 2386 .attach = ni_usb_attach, 2387 .detach = ni_usb_detach, 2388 .read = ni_usb_read, 2389 .write = ni_usb_write, 2390 .command = ni_usb_command, 2391 .take_control = ni_usb_take_control, 2392 .go_to_standby = ni_usb_go_to_standby, 2393 .request_system_control = ni_usb_request_system_control, 2394 .interface_clear = ni_usb_interface_clear, 2395 .remote_enable = ni_usb_remote_enable, 2396 .enable_eos = ni_usb_enable_eos, 2397 .disable_eos = ni_usb_disable_eos, 2398 .parallel_poll = ni_usb_parallel_poll, 2399 .parallel_poll_configure = ni_usb_parallel_poll_configure, 2400 .parallel_poll_response = ni_usb_parallel_poll_response, 2401 .local_parallel_poll_mode = NULL, // XXX 2402 .line_status = ni_usb_line_status, 2403 .update_status = ni_usb_update_status, 2404 .primary_address = ni_usb_primary_address, 2405 .secondary_address = ni_usb_secondary_address, 2406 .serial_poll_response = ni_usb_serial_poll_response, 2407 .serial_poll_status = ni_usb_serial_poll_status, 2408 .t1_delay = ni_usb_t1_delay, 2409 .return_to_local = ni_usb_return_to_local, 2410 .skip_check_for_command_acceptors = 1 2411 }; 2412 2413 // Table with the USB-devices: just now only testing IDs 2414 static struct usb_device_id ni_usb_driver_device_table[] = { 2415 {USB_DEVICE(USB_VENDOR_ID_NI, USB_DEVICE_ID_NI_USB_B)}, 2416 {USB_DEVICE(USB_VENDOR_ID_NI, USB_DEVICE_ID_NI_USB_HS)}, 2417 // gpib-usb-hs+ has a second interface for the analyzer, which we ignore 2418 {USB_DEVICE_INTERFACE_NUMBER(USB_VENDOR_ID_NI, USB_DEVICE_ID_NI_USB_HS_PLUS, 0)}, 2419 {USB_DEVICE(USB_VENDOR_ID_NI, USB_DEVICE_ID_KUSB_488A)}, 2420 {USB_DEVICE(USB_VENDOR_ID_NI, USB_DEVICE_ID_MC_USB_488)}, 2421 {} /* Terminating entry */ 2422 }; 2423 MODULE_DEVICE_TABLE(usb, ni_usb_driver_device_table); 2424 2425 static int ni_usb_driver_probe(struct usb_interface *interface, const struct usb_device_id *id) 2426 { 2427 struct usb_device *usb_dev = interface_to_usbdev(interface); 2428 int i; 2429 char *path; 2430 static const int path_length = 1024; 2431 2432 mutex_lock(&ni_usb_hotplug_lock); 2433 usb_get_dev(usb_dev); 2434 for (i = 0; i < MAX_NUM_NI_USB_INTERFACES; i++) { 2435 if (!ni_usb_driver_interfaces[i]) { 2436 ni_usb_driver_interfaces[i] = interface; 2437 usb_set_intfdata(interface, NULL); 2438 break; 2439 } 2440 } 2441 if (i == MAX_NUM_NI_USB_INTERFACES) { 2442 usb_put_dev(usb_dev); 2443 mutex_unlock(&ni_usb_hotplug_lock); 2444 dev_err(&usb_dev->dev, "ni_usb_driver_interfaces[] full\n"); 2445 return -1; 2446 } 2447 path = kmalloc(path_length, GFP_KERNEL); 2448 if (!path) { 2449 usb_put_dev(usb_dev); 2450 mutex_unlock(&ni_usb_hotplug_lock); 2451 return -ENOMEM; 2452 } 2453 usb_make_path(usb_dev, path, path_length); 2454 dev_info(&usb_dev->dev, "probe succeeded for path: %s\n", path); 2455 kfree(path); 2456 mutex_unlock(&ni_usb_hotplug_lock); 2457 return 0; 2458 } 2459 2460 static void ni_usb_driver_disconnect(struct usb_interface *interface) 2461 { 2462 struct usb_device *usb_dev = interface_to_usbdev(interface); 2463 int i; 2464 2465 mutex_lock(&ni_usb_hotplug_lock); 2466 for (i = 0; i < MAX_NUM_NI_USB_INTERFACES; i++) { 2467 if (ni_usb_driver_interfaces[i] == interface) { 2468 struct gpib_board *board = usb_get_intfdata(interface); 2469 2470 if (board) { 2471 struct ni_usb_priv *ni_priv = board->private_data; 2472 2473 if (ni_priv) { 2474 mutex_lock(&ni_priv->bulk_transfer_lock); 2475 mutex_lock(&ni_priv->control_transfer_lock); 2476 mutex_lock(&ni_priv->interrupt_transfer_lock); 2477 ni_usb_cleanup_urbs(ni_priv); 2478 ni_priv->bus_interface = NULL; 2479 mutex_unlock(&ni_priv->interrupt_transfer_lock); 2480 mutex_unlock(&ni_priv->control_transfer_lock); 2481 mutex_unlock(&ni_priv->bulk_transfer_lock); 2482 } 2483 } 2484 ni_usb_driver_interfaces[i] = NULL; 2485 break; 2486 } 2487 } 2488 if (i == MAX_NUM_NI_USB_INTERFACES) 2489 dev_err(&usb_dev->dev, "unable to find interface bug?\n"); 2490 usb_put_dev(usb_dev); 2491 mutex_unlock(&ni_usb_hotplug_lock); 2492 } 2493 2494 static int ni_usb_driver_suspend(struct usb_interface *interface, pm_message_t message) 2495 { 2496 struct usb_device *usb_dev = interface_to_usbdev(interface); 2497 struct gpib_board *board; 2498 int i, retval; 2499 2500 mutex_lock(&ni_usb_hotplug_lock); 2501 2502 for (i = 0; i < MAX_NUM_NI_USB_INTERFACES; i++) { 2503 if (ni_usb_driver_interfaces[i] == interface) { 2504 board = usb_get_intfdata(interface); 2505 if (board) 2506 break; 2507 } 2508 } 2509 if (i == MAX_NUM_NI_USB_INTERFACES) { 2510 mutex_unlock(&ni_usb_hotplug_lock); 2511 return 0; 2512 } 2513 2514 struct ni_usb_priv *ni_priv = board->private_data; 2515 2516 if (ni_priv) { 2517 ni_usb_set_interrupt_monitor(board, 0); 2518 retval = ni_usb_shutdown_hardware(ni_priv); 2519 if (retval) { 2520 mutex_unlock(&ni_usb_hotplug_lock); 2521 return retval; 2522 } 2523 if (ni_priv->interrupt_urb) { 2524 mutex_lock(&ni_priv->interrupt_transfer_lock); 2525 ni_usb_cleanup_urbs(ni_priv); 2526 mutex_unlock(&ni_priv->interrupt_transfer_lock); 2527 } 2528 dev_dbg(&usb_dev->dev, 2529 "bus %d dev num %d gpib%d, interface %i suspended\n", 2530 usb_dev->bus->busnum, usb_dev->devnum, board->minor, i); 2531 } 2532 2533 mutex_unlock(&ni_usb_hotplug_lock); 2534 return 0; 2535 } 2536 2537 static int ni_usb_driver_resume(struct usb_interface *interface) 2538 { 2539 struct usb_device *usb_dev = interface_to_usbdev(interface); 2540 2541 struct gpib_board *board; 2542 int i, retval; 2543 2544 mutex_lock(&ni_usb_hotplug_lock); 2545 2546 for (i = 0; i < MAX_NUM_NI_USB_INTERFACES; i++) { 2547 if (ni_usb_driver_interfaces[i] == interface) { 2548 board = usb_get_intfdata(interface); 2549 if (board) 2550 break; 2551 } 2552 } 2553 if (i == MAX_NUM_NI_USB_INTERFACES) { 2554 mutex_unlock(&ni_usb_hotplug_lock); 2555 return 0; 2556 } 2557 2558 struct ni_usb_priv *ni_priv = board->private_data; 2559 2560 if (ni_priv) { 2561 if (ni_priv->interrupt_urb) { 2562 mutex_lock(&ni_priv->interrupt_transfer_lock); 2563 retval = usb_submit_urb(ni_priv->interrupt_urb, GFP_KERNEL); 2564 if (retval) { 2565 dev_err(&usb_dev->dev, "resume failed to resubmit interrupt urb, retval=%i\n", 2566 retval); 2567 mutex_unlock(&ni_priv->interrupt_transfer_lock); 2568 mutex_unlock(&ni_usb_hotplug_lock); 2569 return retval; 2570 } 2571 mutex_unlock(&ni_priv->interrupt_transfer_lock); 2572 } else { 2573 dev_err(&usb_dev->dev, "bug! resume int urb not set up\n"); 2574 mutex_unlock(&ni_usb_hotplug_lock); 2575 return -EINVAL; 2576 } 2577 2578 switch (ni_priv->product_id) { 2579 case USB_DEVICE_ID_NI_USB_B: 2580 ni_usb_b_read_serial_number(ni_priv); 2581 break; 2582 case USB_DEVICE_ID_NI_USB_HS: 2583 case USB_DEVICE_ID_MC_USB_488: 2584 case USB_DEVICE_ID_KUSB_488A: 2585 retval = ni_usb_hs_wait_for_ready(ni_priv); 2586 if (retval < 0) { 2587 mutex_unlock(&ni_usb_hotplug_lock); 2588 return retval; 2589 } 2590 break; 2591 case USB_DEVICE_ID_NI_USB_HS_PLUS: 2592 retval = ni_usb_hs_wait_for_ready(ni_priv); 2593 if (retval < 0) { 2594 mutex_unlock(&ni_usb_hotplug_lock); 2595 return retval; 2596 } 2597 retval = ni_usb_hs_plus_extra_init(ni_priv); 2598 if (retval < 0) { 2599 mutex_unlock(&ni_usb_hotplug_lock); 2600 return retval; 2601 } 2602 break; 2603 default: 2604 mutex_unlock(&ni_usb_hotplug_lock); 2605 dev_err(&usb_dev->dev, "\tDriver bug: unknown endpoints for usb device id\n"); 2606 return -EINVAL; 2607 } 2608 2609 retval = ni_usb_set_interrupt_monitor(board, 0); 2610 if (retval < 0) { 2611 mutex_unlock(&ni_usb_hotplug_lock); 2612 return retval; 2613 } 2614 2615 retval = ni_usb_init(board); 2616 if (retval < 0) { 2617 mutex_unlock(&ni_usb_hotplug_lock); 2618 return retval; 2619 } 2620 retval = ni_usb_set_interrupt_monitor(board, ni_usb_ibsta_monitor_mask); 2621 if (retval < 0) { 2622 mutex_unlock(&ni_usb_hotplug_lock); 2623 return retval; 2624 } 2625 if (board->master) 2626 ni_usb_interface_clear(board, 1); // this is a pulsed action 2627 if (ni_priv->ren_state) 2628 ni_usb_remote_enable(board, 1); 2629 2630 dev_dbg(&usb_dev->dev, 2631 "bus %d dev num %d gpib%d, interface %i resumed\n", 2632 usb_dev->bus->busnum, usb_dev->devnum, board->minor, i); 2633 } 2634 2635 mutex_unlock(&ni_usb_hotplug_lock); 2636 return 0; 2637 } 2638 2639 static struct usb_driver ni_usb_bus_driver = { 2640 .name = DRV_NAME, 2641 .probe = ni_usb_driver_probe, 2642 .disconnect = ni_usb_driver_disconnect, 2643 .suspend = ni_usb_driver_suspend, 2644 .resume = ni_usb_driver_resume, 2645 .id_table = ni_usb_driver_device_table, 2646 }; 2647 2648 static int __init ni_usb_init_module(void) 2649 { 2650 int i; 2651 int ret; 2652 2653 for (i = 0; i < MAX_NUM_NI_USB_INTERFACES; i++) 2654 ni_usb_driver_interfaces[i] = NULL; 2655 2656 ret = usb_register(&ni_usb_bus_driver); 2657 if (ret) { 2658 pr_err("usb_register failed: error = %d\n", ret); 2659 return ret; 2660 } 2661 2662 ret = gpib_register_driver(&ni_usb_gpib_interface, THIS_MODULE); 2663 if (ret) { 2664 pr_err("gpib_register_driver failed: error = %d\n", ret); 2665 return ret; 2666 } 2667 2668 return 0; 2669 } 2670 2671 static void __exit ni_usb_exit_module(void) 2672 { 2673 gpib_unregister_driver(&ni_usb_gpib_interface); 2674 usb_deregister(&ni_usb_bus_driver); 2675 } 2676 2677 module_init(ni_usb_init_module); 2678 module_exit(ni_usb_exit_module); 2679