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 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
ni_usb_parse_status_block(const u8 * buffer,struct ni_usb_status_block * status)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
ni_usb_dump_raw_block(const u8 * raw_data,int length)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
ni_usb_parse_register_read_block(const u8 * raw_data,unsigned int * results,int num_results)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
ni_usb_parse_termination_block(const u8 * buffer)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
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)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
ni_usb_parse_reg_write_status_block(const u8 * raw_data,struct ni_usb_status_block * status,int * writes_completed)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
ni_usb_write_registers(struct ni_usb_priv * ni_priv,const struct ni_usb_register * writes,int num_writes,unsigned int * ibsta)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
ni_usb_read(struct gpib_board * board,u8 * buffer,size_t length,int * end,size_t * bytes_read)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
ni_usb_write(struct gpib_board * board,u8 * buffer,size_t length,int send_eoi,size_t * bytes_written)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
ni_usb_command_chunk(struct gpib_board * board,u8 * buffer,size_t length,size_t * command_bytes_written)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
ni_usb_command(struct gpib_board * board,u8 * buffer,size_t length,size_t * bytes_written)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
ni_usb_take_control(struct gpib_board * board,int synchronous)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
ni_usb_go_to_standby(struct gpib_board * board)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
ni_usb_request_system_control(struct gpib_board * board,int request_control)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?
ni_usb_interface_clear(struct gpib_board * board,int assert)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
ni_usb_remote_enable(struct gpib_board * board,int enable)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
ni_usb_enable_eos(struct gpib_board * board,u8 eos_byte,int compare_8_bits)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
ni_usb_disable_eos(struct gpib_board * board)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
ni_usb_update_status(struct gpib_board * board,unsigned int clear_mask)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
ni_usb_stop(struct ni_usb_priv * ni_priv)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
ni_usb_primary_address(struct gpib_board * board,unsigned int address)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
ni_usb_write_sad(struct ni_usb_register * writes,int address,int enable)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
ni_usb_secondary_address(struct gpib_board * board,unsigned int address,int enable)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
ni_usb_parallel_poll(struct gpib_board * board,u8 * result)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
ni_usb_parallel_poll_configure(struct gpib_board * board,u8 config)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
ni_usb_parallel_poll_response(struct gpib_board * board,int ist)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
ni_usb_serial_poll_response(struct gpib_board * board,u8 status)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
ni_usb_serial_poll_status(struct gpib_board * board)1485 static u8 ni_usb_serial_poll_status(struct gpib_board *board)
1486 {
1487 return 0;
1488 }
1489
ni_usb_return_to_local(struct gpib_board * board)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
ni_usb_line_status(const struct gpib_board * board)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
ni_usb_setup_t1_delay(struct ni_usb_register * reg,unsigned int nano_sec,unsigned int * actual_ns)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
ni_usb_t1_delay(struct gpib_board * board,unsigned int nano_sec)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
ni_usb_allocate_private(struct gpib_board * board)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
ni_usb_free_private(struct ni_usb_priv * ni_priv)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
ni_usb_setup_init(struct gpib_board * board,struct ni_usb_register * writes)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
ni_usb_init(struct gpib_board * board)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
ni_usb_interrupt_complete(struct urb * urb)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
ni_usb_set_interrupt_monitor(struct gpib_board * board,unsigned int monitored_bits)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
ni_usb_setup_urbs(struct gpib_board * board)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
ni_usb_cleanup_urbs(struct ni_usb_priv * ni_priv)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
ni_usb_b_read_serial_number(struct ni_usb_priv * ni_priv)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
ni_usb_hs_wait_for_ready(struct ni_usb_priv * ni_priv)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 */
ni_usb_hs_plus_extra_init(struct ni_usb_priv * ni_priv)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
ni_usb_device_match(struct usb_interface * interface,const struct gpib_board_config * config)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
ni_usb_attach(struct gpib_board * board,const struct gpib_board_config * config)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
ni_usb_shutdown_hardware(struct ni_usb_priv * ni_priv)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
ni_usb_detach(struct gpib_board * board)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
ni_usb_driver_probe(struct usb_interface * interface,const struct usb_device_id * id)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
ni_usb_driver_disconnect(struct usb_interface * interface)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
ni_usb_driver_suspend(struct usb_interface * interface,pm_message_t message)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
ni_usb_driver_resume(struct usb_interface * interface)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
ni_usb_init_module(void)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
ni_usb_exit_module(void)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