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