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