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