1 // SPDX-License-Identifier: GPL-2.0
2
3 /***************************************************************************
4 * driver for Agilent 82357A/B usb to gpib adapters *
5 * copyright : (C) 2004 by Frank Mori Hess *
6 ***************************************************************************/
7
8 #define _GNU_SOURCE
9
10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11 #define dev_fmt pr_fmt
12 #define DRV_NAME KBUILD_MODNAME
13
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/slab.h>
17 #include "agilent_82357a.h"
18 #include "gpibP.h"
19 #include "tms9914.h"
20
21 MODULE_LICENSE("GPL");
22 MODULE_DESCRIPTION("GPIB driver for Agilent 82357A/B usb adapters");
23
24 #define MAX_NUM_82357A_INTERFACES 128
25 static struct usb_interface *agilent_82357a_driver_interfaces[MAX_NUM_82357A_INTERFACES];
26 static DEFINE_MUTEX(agilent_82357a_hotplug_lock); // protect board insertion and removal
27
28 static unsigned int agilent_82357a_update_status(struct gpib_board *board,
29 unsigned int clear_mask);
30
31 static int agilent_82357a_take_control_internal(struct gpib_board *board, int synchronous);
32
agilent_82357a_bulk_complete(struct urb * urb)33 static void agilent_82357a_bulk_complete(struct urb *urb)
34 {
35 struct agilent_82357a_urb_ctx *context = urb->context;
36
37 complete(&context->complete);
38 }
39
agilent_82357a_timeout_handler(struct timer_list * t)40 static void agilent_82357a_timeout_handler(struct timer_list *t)
41 {
42 struct agilent_82357a_priv *a_priv = timer_container_of(a_priv, t,
43 bulk_timer);
44 struct agilent_82357a_urb_ctx *context = &a_priv->context;
45
46 context->timed_out = 1;
47 complete(&context->complete);
48 }
49
agilent_82357a_send_bulk_msg(struct agilent_82357a_priv * a_priv,void * data,int data_length,int * actual_data_length,int timeout_msecs)50 static int agilent_82357a_send_bulk_msg(struct agilent_82357a_priv *a_priv, void *data,
51 int data_length, int *actual_data_length,
52 int timeout_msecs)
53 {
54 struct usb_device *usb_dev;
55 int retval;
56 unsigned int out_pipe;
57 struct agilent_82357a_urb_ctx *context = &a_priv->context;
58
59 *actual_data_length = 0;
60 retval = mutex_lock_interruptible(&a_priv->bulk_alloc_lock);
61 if (retval)
62 return retval;
63 if (!a_priv->bus_interface) {
64 mutex_unlock(&a_priv->bulk_alloc_lock);
65 return -ENODEV;
66 }
67 if (a_priv->bulk_urb) {
68 mutex_unlock(&a_priv->bulk_alloc_lock);
69 return -EAGAIN;
70 }
71 a_priv->bulk_urb = usb_alloc_urb(0, GFP_KERNEL);
72 if (!a_priv->bulk_urb) {
73 mutex_unlock(&a_priv->bulk_alloc_lock);
74 return -ENOMEM;
75 }
76 usb_dev = interface_to_usbdev(a_priv->bus_interface);
77 out_pipe = usb_sndbulkpipe(usb_dev, a_priv->bulk_out_endpoint);
78 init_completion(&context->complete);
79 context->timed_out = 0;
80 usb_fill_bulk_urb(a_priv->bulk_urb, usb_dev, out_pipe, data, data_length,
81 &agilent_82357a_bulk_complete, context);
82
83 if (timeout_msecs)
84 mod_timer(&a_priv->bulk_timer, jiffies + msecs_to_jiffies(timeout_msecs));
85
86 retval = usb_submit_urb(a_priv->bulk_urb, GFP_KERNEL);
87 if (retval) {
88 dev_err(&usb_dev->dev, "failed to submit bulk out urb, retval=%i\n", retval);
89 mutex_unlock(&a_priv->bulk_alloc_lock);
90 goto cleanup;
91 }
92 mutex_unlock(&a_priv->bulk_alloc_lock);
93 if (wait_for_completion_interruptible(&context->complete)) {
94 retval = -ERESTARTSYS;
95 goto cleanup;
96 }
97 if (context->timed_out) {
98 retval = -ETIMEDOUT;
99 } else {
100 retval = a_priv->bulk_urb->status;
101 *actual_data_length = a_priv->bulk_urb->actual_length;
102 }
103 cleanup:
104 if (timeout_msecs) {
105 if (timer_pending(&a_priv->bulk_timer))
106 timer_delete_sync(&a_priv->bulk_timer);
107 }
108 mutex_lock(&a_priv->bulk_alloc_lock);
109 if (a_priv->bulk_urb) {
110 usb_kill_urb(a_priv->bulk_urb);
111 usb_free_urb(a_priv->bulk_urb);
112 a_priv->bulk_urb = NULL;
113 }
114 mutex_unlock(&a_priv->bulk_alloc_lock);
115 return retval;
116 }
117
agilent_82357a_receive_bulk_msg(struct agilent_82357a_priv * a_priv,void * data,int data_length,int * actual_data_length,int timeout_msecs)118 static int agilent_82357a_receive_bulk_msg(struct agilent_82357a_priv *a_priv, void *data,
119 int data_length, int *actual_data_length,
120 int timeout_msecs)
121 {
122 struct usb_device *usb_dev;
123 int retval;
124 unsigned int in_pipe;
125 struct agilent_82357a_urb_ctx *context = &a_priv->context;
126
127 *actual_data_length = 0;
128 retval = mutex_lock_interruptible(&a_priv->bulk_alloc_lock);
129 if (retval)
130 return retval;
131 if (!a_priv->bus_interface) {
132 mutex_unlock(&a_priv->bulk_alloc_lock);
133 return -ENODEV;
134 }
135 if (a_priv->bulk_urb) {
136 mutex_unlock(&a_priv->bulk_alloc_lock);
137 return -EAGAIN;
138 }
139 a_priv->bulk_urb = usb_alloc_urb(0, GFP_KERNEL);
140 if (!a_priv->bulk_urb) {
141 mutex_unlock(&a_priv->bulk_alloc_lock);
142 return -ENOMEM;
143 }
144 usb_dev = interface_to_usbdev(a_priv->bus_interface);
145 in_pipe = usb_rcvbulkpipe(usb_dev, AGILENT_82357_BULK_IN_ENDPOINT);
146 init_completion(&context->complete);
147 context->timed_out = 0;
148 usb_fill_bulk_urb(a_priv->bulk_urb, usb_dev, in_pipe, data, data_length,
149 &agilent_82357a_bulk_complete, context);
150
151 if (timeout_msecs)
152 mod_timer(&a_priv->bulk_timer, jiffies + msecs_to_jiffies(timeout_msecs));
153
154 retval = usb_submit_urb(a_priv->bulk_urb, GFP_KERNEL);
155 if (retval) {
156 dev_err(&usb_dev->dev, "failed to submit bulk in urb, retval=%i\n", retval);
157 mutex_unlock(&a_priv->bulk_alloc_lock);
158 goto cleanup;
159 }
160 mutex_unlock(&a_priv->bulk_alloc_lock);
161 if (wait_for_completion_interruptible(&context->complete)) {
162 retval = -ERESTARTSYS;
163 goto cleanup;
164 }
165 if (context->timed_out) {
166 retval = -ETIMEDOUT;
167 goto cleanup;
168 }
169 retval = a_priv->bulk_urb->status;
170 *actual_data_length = a_priv->bulk_urb->actual_length;
171 cleanup:
172 if (timeout_msecs)
173 timer_delete_sync(&a_priv->bulk_timer);
174
175 mutex_lock(&a_priv->bulk_alloc_lock);
176 if (a_priv->bulk_urb) {
177 usb_kill_urb(a_priv->bulk_urb);
178 usb_free_urb(a_priv->bulk_urb);
179 a_priv->bulk_urb = NULL;
180 }
181 mutex_unlock(&a_priv->bulk_alloc_lock);
182 return retval;
183 }
184
agilent_82357a_receive_control_msg(struct agilent_82357a_priv * a_priv,__u8 request,__u8 requesttype,__u16 value,__u16 index,void * data,__u16 size,int timeout_msecs)185 static int agilent_82357a_receive_control_msg(struct agilent_82357a_priv *a_priv, __u8 request,
186 __u8 requesttype, __u16 value, __u16 index,
187 void *data, __u16 size, int timeout_msecs)
188 {
189 struct usb_device *usb_dev;
190 int retval;
191 unsigned int in_pipe;
192
193 retval = mutex_lock_interruptible(&a_priv->control_alloc_lock);
194 if (retval)
195 return retval;
196 if (!a_priv->bus_interface) {
197 mutex_unlock(&a_priv->control_alloc_lock);
198 return -ENODEV;
199 }
200 usb_dev = interface_to_usbdev(a_priv->bus_interface);
201 in_pipe = usb_rcvctrlpipe(usb_dev, AGILENT_82357_CONTROL_ENDPOINT);
202 retval = usb_control_msg(usb_dev, in_pipe, request, requesttype, value, index, data,
203 size, timeout_msecs);
204 mutex_unlock(&a_priv->control_alloc_lock);
205 return retval;
206 }
207
agilent_82357a_dump_raw_block(const u8 * raw_data,int length)208 static void agilent_82357a_dump_raw_block(const u8 *raw_data, int length)
209 {
210 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 8, 1, raw_data, length, true);
211 }
212
agilent_82357a_write_registers(struct agilent_82357a_priv * a_priv,const struct agilent_82357a_register_pairlet * writes,int num_writes)213 static int agilent_82357a_write_registers(struct agilent_82357a_priv *a_priv,
214 const struct agilent_82357a_register_pairlet *writes,
215 int num_writes)
216 {
217 struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface);
218 int retval;
219 u8 *out_data, *in_data;
220 int out_data_length, in_data_length;
221 int bytes_written, bytes_read;
222 int i = 0;
223 int j;
224 static const int bytes_per_write = 2;
225 static const int header_length = 2;
226 static const int max_writes = 31;
227
228 if (num_writes > max_writes) {
229 dev_err(&usb_dev->dev, "bug! num_writes=%i too large\n", num_writes);
230 return -EIO;
231 }
232 out_data_length = num_writes * bytes_per_write + header_length;
233 out_data = kmalloc(out_data_length, GFP_KERNEL);
234 if (!out_data)
235 return -ENOMEM;
236
237 out_data[i++] = DATA_PIPE_CMD_WR_REGS;
238 out_data[i++] = num_writes;
239 for (j = 0; j < num_writes; j++) {
240 out_data[i++] = writes[j].address;
241 out_data[i++] = writes[j].value;
242 }
243
244 retval = mutex_lock_interruptible(&a_priv->bulk_transfer_lock);
245 if (retval) {
246 kfree(out_data);
247 return retval;
248 }
249 retval = agilent_82357a_send_bulk_msg(a_priv, out_data, i, &bytes_written, 1000);
250 kfree(out_data);
251 if (retval) {
252 dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n",
253 retval, bytes_written, i);
254 mutex_unlock(&a_priv->bulk_transfer_lock);
255 return retval;
256 }
257 in_data_length = 0x20;
258 in_data = kmalloc(in_data_length, GFP_KERNEL);
259 if (!in_data) {
260 mutex_unlock(&a_priv->bulk_transfer_lock);
261 return -ENOMEM;
262 }
263 retval = agilent_82357a_receive_bulk_msg(a_priv, in_data, in_data_length,
264 &bytes_read, 1000);
265 mutex_unlock(&a_priv->bulk_transfer_lock);
266
267 if (retval) {
268 dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n",
269 retval, bytes_read);
270 agilent_82357a_dump_raw_block(in_data, bytes_read);
271 kfree(in_data);
272 return -EIO;
273 }
274 if (in_data[0] != (0xff & ~DATA_PIPE_CMD_WR_REGS)) {
275 dev_err(&usb_dev->dev, "bulk command=0x%x != ~DATA_PIPE_CMD_WR_REGS\n", in_data[0]);
276 return -EIO;
277 }
278 if (in_data[1]) {
279 dev_err(&usb_dev->dev, "nonzero error code 0x%x in DATA_PIPE_CMD_WR_REGS response\n",
280 in_data[1]);
281 return -EIO;
282 }
283 kfree(in_data);
284 return 0;
285 }
286
agilent_82357a_read_registers(struct agilent_82357a_priv * a_priv,struct agilent_82357a_register_pairlet * reads,int num_reads,int blocking)287 static int agilent_82357a_read_registers(struct agilent_82357a_priv *a_priv,
288 struct agilent_82357a_register_pairlet *reads,
289 int num_reads, int blocking)
290 {
291 struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface);
292 int retval;
293 u8 *out_data, *in_data;
294 int out_data_length, in_data_length;
295 int bytes_written, bytes_read;
296 int i = 0;
297 int j;
298 static const int header_length = 2;
299 static const int max_reads = 62;
300
301 if (num_reads > max_reads) {
302 dev_err(&usb_dev->dev, "bug! num_reads=%i too large\n", num_reads);
303 return -EIO;
304 }
305 out_data_length = num_reads + header_length;
306 out_data = kmalloc(out_data_length, GFP_KERNEL);
307 if (!out_data)
308 return -ENOMEM;
309
310 out_data[i++] = DATA_PIPE_CMD_RD_REGS;
311 out_data[i++] = num_reads;
312 for (j = 0; j < num_reads; j++)
313 out_data[i++] = reads[j].address;
314
315 if (blocking) {
316 retval = mutex_lock_interruptible(&a_priv->bulk_transfer_lock);
317 if (retval) {
318 kfree(out_data);
319 return retval;
320 }
321 } else {
322 retval = mutex_trylock(&a_priv->bulk_transfer_lock);
323 if (retval == 0) {
324 kfree(out_data);
325 return -EAGAIN;
326 }
327 }
328 retval = agilent_82357a_send_bulk_msg(a_priv, out_data, i, &bytes_written, 1000);
329 kfree(out_data);
330 if (retval) {
331 dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n",
332 retval, bytes_written, i);
333 mutex_unlock(&a_priv->bulk_transfer_lock);
334 return retval;
335 }
336 in_data_length = 0x20;
337 in_data = kmalloc(in_data_length, GFP_KERNEL);
338 if (!in_data) {
339 mutex_unlock(&a_priv->bulk_transfer_lock);
340 return -ENOMEM;
341 }
342 retval = agilent_82357a_receive_bulk_msg(a_priv, in_data, in_data_length,
343 &bytes_read, 10000);
344 mutex_unlock(&a_priv->bulk_transfer_lock);
345
346 if (retval) {
347 dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n",
348 retval, bytes_read);
349 agilent_82357a_dump_raw_block(in_data, bytes_read);
350 kfree(in_data);
351 return -EIO;
352 }
353 i = 0;
354 if (in_data[i++] != (0xff & ~DATA_PIPE_CMD_RD_REGS)) {
355 dev_err(&usb_dev->dev, "bulk command=0x%x != ~DATA_PIPE_CMD_RD_REGS\n", in_data[0]);
356 return -EIO;
357 }
358 if (in_data[i++]) {
359 dev_err(&usb_dev->dev, "nonzero error code 0x%x in DATA_PIPE_CMD_RD_REGS response\n",
360 in_data[1]);
361 return -EIO;
362 }
363 for (j = 0; j < num_reads; j++)
364 reads[j].value = in_data[i++];
365 kfree(in_data);
366 return 0;
367 }
368
agilent_82357a_abort(struct agilent_82357a_priv * a_priv,int flush)369 static int agilent_82357a_abort(struct agilent_82357a_priv *a_priv, int flush)
370 {
371 struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface);
372 int retval = 0;
373 int receive_control_retval;
374 u16 wIndex = 0;
375 u8 *status_data;
376 static const unsigned int status_data_len = 2;
377
378 status_data = kmalloc(status_data_len, GFP_KERNEL);
379 if (!status_data)
380 return -ENOMEM;
381
382 if (flush)
383 wIndex |= XA_FLUSH;
384 receive_control_retval = agilent_82357a_receive_control_msg(a_priv,
385 agilent_82357a_control_request,
386 USB_DIR_IN | USB_TYPE_VENDOR |
387 USB_RECIP_DEVICE, XFER_ABORT,
388 wIndex, status_data,
389 status_data_len, 100);
390 if (receive_control_retval < 0) {
391 dev_err(&usb_dev->dev, "82357a_receive_control_msg() returned %i\n",
392 receive_control_retval);
393 retval = -EIO;
394 goto cleanup;
395 }
396 if (status_data[0] != (~XFER_ABORT & 0xff)) {
397 dev_err(&usb_dev->dev, "major code=0x%x != ~XFER_ABORT\n", status_data[0]);
398 retval = -EIO;
399 goto cleanup;
400 }
401 switch (status_data[1]) {
402 case UGP_SUCCESS:
403 retval = 0;
404 break;
405 case UGP_ERR_FLUSHING:
406 if (flush) {
407 retval = 0;
408 break;
409 }
410 fallthrough;
411 case UGP_ERR_FLUSHING_ALREADY:
412 default:
413 dev_err(&usb_dev->dev, "abort returned error code=0x%x\n", status_data[1]);
414 retval = -EIO;
415 break;
416 }
417
418 cleanup:
419 kfree(status_data);
420 return retval;
421 }
422
423 // interface functions
424 int agilent_82357a_command(struct gpib_board *board, u8 *buffer, size_t length,
425 size_t *bytes_written);
426
agilent_82357a_read(struct gpib_board * board,u8 * buffer,size_t length,int * end,size_t * nbytes)427 static int agilent_82357a_read(struct gpib_board *board, u8 *buffer, size_t length, int *end,
428 size_t *nbytes)
429 {
430 int retval;
431 struct agilent_82357a_priv *a_priv = board->private_data;
432 struct usb_device *usb_dev;
433 u8 *out_data, *in_data;
434 int out_data_length, in_data_length;
435 int bytes_written, bytes_read;
436 int i = 0;
437 u8 trailing_flags;
438 unsigned long start_jiffies = jiffies;
439 int msec_timeout;
440
441 *nbytes = 0;
442 *end = 0;
443
444 if (!a_priv->bus_interface)
445 return -ENODEV;
446 usb_dev = interface_to_usbdev(a_priv->bus_interface);
447 out_data_length = 0x9;
448 out_data = kmalloc(out_data_length, GFP_KERNEL);
449 if (!out_data)
450 return -ENOMEM;
451 out_data[i++] = DATA_PIPE_CMD_READ;
452 out_data[i++] = 0; // primary address when ARF_NO_ADDR is not set
453 out_data[i++] = 0; // secondary address when ARF_NO_ADDR is not set
454 out_data[i] = ARF_NO_ADDRESS | ARF_END_ON_EOI;
455 if (a_priv->eos_mode & REOS)
456 out_data[i] |= ARF_END_ON_EOS_CHAR;
457 ++i;
458 out_data[i++] = length & 0xff;
459 out_data[i++] = (length >> 8) & 0xff;
460 out_data[i++] = (length >> 16) & 0xff;
461 out_data[i++] = (length >> 24) & 0xff;
462 out_data[i++] = a_priv->eos_char;
463 msec_timeout = (board->usec_timeout + 999) / 1000;
464 retval = mutex_lock_interruptible(&a_priv->bulk_transfer_lock);
465 if (retval) {
466 kfree(out_data);
467 return retval;
468 }
469 retval = agilent_82357a_send_bulk_msg(a_priv, out_data, i, &bytes_written, msec_timeout);
470 kfree(out_data);
471 if (retval || bytes_written != i) {
472 dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n",
473 retval, bytes_written, i);
474 mutex_unlock(&a_priv->bulk_transfer_lock);
475 if (retval < 0)
476 return retval;
477 return -EIO;
478 }
479 in_data_length = length + 1;
480 in_data = kmalloc(in_data_length, GFP_KERNEL);
481 if (!in_data) {
482 mutex_unlock(&a_priv->bulk_transfer_lock);
483 return -ENOMEM;
484 }
485 if (board->usec_timeout != 0)
486 msec_timeout -= jiffies_to_msecs(jiffies - start_jiffies) - 1;
487 if (msec_timeout >= 0) {
488 retval = agilent_82357a_receive_bulk_msg(a_priv, in_data, in_data_length,
489 &bytes_read, msec_timeout);
490 } else {
491 retval = -ETIMEDOUT;
492 bytes_read = 0;
493 }
494 if (retval == -ETIMEDOUT) {
495 int extra_bytes_read;
496 int extra_bytes_retval;
497
498 agilent_82357a_abort(a_priv, 1);
499 extra_bytes_retval = agilent_82357a_receive_bulk_msg(a_priv, in_data + bytes_read,
500 in_data_length - bytes_read,
501 &extra_bytes_read, 100);
502 bytes_read += extra_bytes_read;
503 if (extra_bytes_retval) {
504 dev_err(&usb_dev->dev, "extra_bytes_retval=%i, bytes_read=%i\n",
505 extra_bytes_retval, bytes_read);
506 agilent_82357a_abort(a_priv, 0);
507 }
508 } else if (retval) {
509 dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n",
510 retval, bytes_read);
511 agilent_82357a_abort(a_priv, 0);
512 }
513 mutex_unlock(&a_priv->bulk_transfer_lock);
514 if (bytes_read > length + 1) {
515 bytes_read = length + 1;
516 dev_warn(&usb_dev->dev, "bytes_read > length? truncating");
517 }
518
519 if (bytes_read >= 1) {
520 memcpy(buffer, in_data, bytes_read - 1);
521 trailing_flags = in_data[bytes_read - 1];
522 *nbytes = bytes_read - 1;
523 if (trailing_flags & (ATRF_EOI | ATRF_EOS))
524 *end = 1;
525 }
526 kfree(in_data);
527
528 /*
529 * Fix for a bug in 9914A that does not return the contents of ADSR
530 * when the board is in listener active state and ATN is not asserted.
531 * Set ATN here to obtain a valid board level ibsta
532 */
533 agilent_82357a_take_control_internal(board, 0);
534
535 // FIXME check trailing flags for error
536 return retval;
537 }
538
agilent_82357a_generic_write(struct gpib_board * board,u8 * buffer,size_t length,int send_commands,int send_eoi,size_t * bytes_written)539 static ssize_t agilent_82357a_generic_write(struct gpib_board *board,
540 u8 *buffer, size_t length,
541 int send_commands, int send_eoi,
542 size_t *bytes_written)
543 {
544 int retval;
545 struct agilent_82357a_priv *a_priv = board->private_data;
546 struct usb_device *usb_dev;
547 u8 *out_data = NULL;
548 u8 *status_data = NULL;
549 int out_data_length;
550 int raw_bytes_written;
551 int i = 0, j;
552 int msec_timeout;
553 unsigned short bsr, adsr;
554 struct agilent_82357a_register_pairlet read_reg;
555
556 *bytes_written = 0;
557 if (!a_priv->bus_interface)
558 return -ENODEV;
559
560 usb_dev = interface_to_usbdev(a_priv->bus_interface);
561 out_data_length = length + 0x8;
562 out_data = kmalloc(out_data_length, GFP_KERNEL);
563 if (!out_data)
564 return -ENOMEM;
565 out_data[i++] = DATA_PIPE_CMD_WRITE;
566 out_data[i++] = 0; // primary address when AWF_NO_ADDRESS is not set
567 out_data[i++] = 0; // secondary address when AWF_NO_ADDRESS is not set
568 out_data[i] = AWF_NO_ADDRESS | AWF_NO_FAST_TALKER_FIRST_BYTE;
569 if (send_commands)
570 out_data[i] |= AWF_ATN | AWF_NO_FAST_TALKER;
571 if (send_eoi)
572 out_data[i] |= AWF_SEND_EOI;
573 ++i;
574 out_data[i++] = length & 0xff;
575 out_data[i++] = (length >> 8) & 0xff;
576 out_data[i++] = (length >> 16) & 0xff;
577 out_data[i++] = (length >> 24) & 0xff;
578 for (j = 0; j < length; j++)
579 out_data[i++] = buffer[j];
580
581 clear_bit(AIF_WRITE_COMPLETE_BN, &a_priv->interrupt_flags);
582
583 msec_timeout = (board->usec_timeout + 999) / 1000;
584 retval = mutex_lock_interruptible(&a_priv->bulk_transfer_lock);
585 if (retval) {
586 kfree(out_data);
587 return retval;
588 }
589 retval = agilent_82357a_send_bulk_msg(a_priv, out_data, i, &raw_bytes_written,
590 msec_timeout);
591 kfree(out_data);
592 if (retval || raw_bytes_written != i) {
593 agilent_82357a_abort(a_priv, 0);
594 dev_err(&usb_dev->dev, "send_bulk_msg returned %i, raw_bytes_written=%i, i=%i\n",
595 retval, raw_bytes_written, i);
596 mutex_unlock(&a_priv->bulk_transfer_lock);
597 if (retval < 0)
598 return retval;
599 return -EIO;
600 }
601
602 retval = wait_event_interruptible(board->wait,
603 test_bit(AIF_WRITE_COMPLETE_BN,
604 &a_priv->interrupt_flags) ||
605 test_bit(TIMO_NUM, &board->status));
606 if (retval) {
607 dev_dbg(&usb_dev->dev, "wait write complete interrupted\n");
608 agilent_82357a_abort(a_priv, 0);
609 mutex_unlock(&a_priv->bulk_transfer_lock);
610 return -ERESTARTSYS;
611 }
612
613 if (test_bit(AIF_WRITE_COMPLETE_BN, &a_priv->interrupt_flags) == 0) {
614 dev_dbg(&usb_dev->dev, "write timed out ibs %i, tmo %i\n",
615 test_bit(TIMO_NUM, &board->status), msec_timeout);
616
617 agilent_82357a_abort(a_priv, 0);
618
619 mutex_unlock(&a_priv->bulk_transfer_lock);
620
621 read_reg.address = BSR;
622 retval = agilent_82357a_read_registers(a_priv, &read_reg, 1, 1);
623 if (retval) {
624 dev_err(&usb_dev->dev, "read_registers() returned error\n");
625 return -ETIMEDOUT;
626 }
627
628 bsr = read_reg.value;
629 dev_dbg(&usb_dev->dev, "write aborted bsr 0x%x\n", bsr);
630
631 if (send_commands) {/* check for no listeners */
632 if ((bsr & BSR_ATN_BIT) && !(bsr & (BSR_NDAC_BIT | BSR_NRFD_BIT))) {
633 dev_dbg(&usb_dev->dev, "No listener on command\n");
634 clear_bit(TIMO_NUM, &board->status);
635 return -ENOTCONN; // no listener on bus
636 }
637 } else {
638 read_reg.address = ADSR;
639 retval = agilent_82357a_read_registers(a_priv, &read_reg, 1, 1);
640 if (retval) {
641 dev_err(&usb_dev->dev, "read_registers() returned error\n");
642 return -ETIMEDOUT;
643 }
644 adsr = read_reg.value;
645 if ((adsr & HR_TA) && !(bsr & (BSR_NDAC_BIT | BSR_NRFD_BIT))) {
646 dev_dbg(&usb_dev->dev, "No listener on write\n");
647 clear_bit(TIMO_NUM, &board->status);
648 return -ECOMM;
649 }
650 }
651
652 return -ETIMEDOUT;
653 }
654
655 status_data = kmalloc(STATUS_DATA_LEN, GFP_KERNEL);
656 if (!status_data) {
657 mutex_unlock(&a_priv->bulk_transfer_lock);
658 return -ENOMEM;
659 }
660
661 retval = agilent_82357a_receive_control_msg(a_priv, agilent_82357a_control_request,
662 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
663 XFER_STATUS, 0, status_data, STATUS_DATA_LEN,
664 100);
665 mutex_unlock(&a_priv->bulk_transfer_lock);
666 if (retval < 0) {
667 dev_err(&usb_dev->dev, "receive_control_msg() returned %i\n", retval);
668 kfree(status_data);
669 return -EIO;
670 }
671 *bytes_written = (u32)status_data[2];
672 *bytes_written |= (u32)status_data[3] << 8;
673 *bytes_written |= (u32)status_data[4] << 16;
674 *bytes_written |= (u32)status_data[5] << 24;
675
676 kfree(status_data);
677 return 0;
678 }
679
agilent_82357a_write(struct gpib_board * board,u8 * buffer,size_t length,int send_eoi,size_t * bytes_written)680 static int agilent_82357a_write(struct gpib_board *board, u8 *buffer,
681 size_t length, int send_eoi, size_t *bytes_written)
682 {
683 return agilent_82357a_generic_write(board, buffer, length, 0, send_eoi, bytes_written);
684 }
685
agilent_82357a_command(struct gpib_board * board,u8 * buffer,size_t length,size_t * bytes_written)686 int agilent_82357a_command(struct gpib_board *board, u8 *buffer, size_t length,
687 size_t *bytes_written)
688 {
689 return agilent_82357a_generic_write(board, buffer, length, 1, 0, bytes_written);
690 }
691
agilent_82357a_take_control_internal(struct gpib_board * board,int synchronous)692 int agilent_82357a_take_control_internal(struct gpib_board *board, int synchronous)
693 {
694 struct agilent_82357a_priv *a_priv = board->private_data;
695 struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface);
696 struct agilent_82357a_register_pairlet write;
697 int retval;
698
699 write.address = AUXCR;
700 if (synchronous)
701 write.value = AUX_TCS;
702 else
703 write.value = AUX_TCA;
704 retval = agilent_82357a_write_registers(a_priv, &write, 1);
705 if (retval)
706 dev_err(&usb_dev->dev, "write_registers() returned error\n");
707
708 return retval;
709 }
710
agilent_82357a_take_control(struct gpib_board * board,int synchronous)711 static int agilent_82357a_take_control(struct gpib_board *board, int synchronous)
712 {
713 struct agilent_82357a_priv *a_priv = board->private_data;
714 const int timeout = 10;
715 int i;
716
717 if (!a_priv->bus_interface)
718 return -ENODEV;
719
720 /*
721 * It looks like the 9914 does not handle tcs properly.
722 * See comment above tms9914_take_control_workaround() in
723 * drivers/gpib/tms9914/tms9914_aux.c
724 */
725 if (synchronous)
726 return -ETIMEDOUT;
727
728 agilent_82357a_take_control_internal(board, synchronous);
729 // busy wait until ATN is asserted
730 for (i = 0; i < timeout; ++i) {
731 agilent_82357a_update_status(board, 0);
732 if (test_bit(ATN_NUM, &board->status))
733 break;
734 udelay(1);
735 }
736 if (i == timeout)
737 return -ETIMEDOUT;
738 return 0;
739 }
740
agilent_82357a_go_to_standby(struct gpib_board * board)741 static int agilent_82357a_go_to_standby(struct gpib_board *board)
742 {
743 struct agilent_82357a_priv *a_priv = board->private_data;
744 struct usb_device *usb_dev;
745 struct agilent_82357a_register_pairlet write;
746 int retval;
747
748 if (!a_priv->bus_interface)
749 return -ENODEV;
750
751 usb_dev = interface_to_usbdev(a_priv->bus_interface);
752 write.address = AUXCR;
753 write.value = AUX_GTS;
754 retval = agilent_82357a_write_registers(a_priv, &write, 1);
755 if (retval)
756 dev_err(&usb_dev->dev, "write_registers() returned error\n");
757 return 0;
758 }
759
agilent_82357a_request_system_control(struct gpib_board * board,int request_control)760 static int agilent_82357a_request_system_control(struct gpib_board *board, int request_control)
761 {
762 struct agilent_82357a_priv *a_priv = board->private_data;
763 struct usb_device *usb_dev;
764 struct agilent_82357a_register_pairlet writes[2];
765 int retval;
766 int i = 0;
767
768 if (!a_priv->bus_interface)
769 return -ENODEV;
770
771 usb_dev = interface_to_usbdev(a_priv->bus_interface);
772 /* 82357B needs bit to be set in 9914 AUXCR register */
773 writes[i].address = AUXCR;
774 if (request_control) {
775 writes[i].value = AUX_RQC;
776 a_priv->hw_control_bits |= SYSTEM_CONTROLLER;
777 } else {
778 return -EINVAL;
779 }
780 ++i;
781 writes[i].address = HW_CONTROL;
782 writes[i].value = a_priv->hw_control_bits;
783 ++i;
784 retval = agilent_82357a_write_registers(a_priv, writes, i);
785 if (retval)
786 dev_err(&usb_dev->dev, "write_registers() returned error\n");
787 return retval;
788 }
789
agilent_82357a_interface_clear(struct gpib_board * board,int assert)790 static void agilent_82357a_interface_clear(struct gpib_board *board, int assert)
791 {
792 struct agilent_82357a_priv *a_priv = board->private_data;
793 struct usb_device *usb_dev;
794 struct agilent_82357a_register_pairlet write;
795 int retval;
796
797 if (!a_priv->bus_interface)
798 return; // -ENODEV;
799
800 usb_dev = interface_to_usbdev(a_priv->bus_interface);
801 write.address = AUXCR;
802 write.value = AUX_SIC;
803 if (assert) {
804 write.value |= AUX_CS;
805 a_priv->is_cic = 1;
806 }
807 retval = agilent_82357a_write_registers(a_priv, &write, 1);
808 if (retval)
809 dev_err(&usb_dev->dev, "write_registers() returned error\n");
810 }
811
agilent_82357a_remote_enable(struct gpib_board * board,int enable)812 static void agilent_82357a_remote_enable(struct gpib_board *board, int enable)
813 {
814 struct agilent_82357a_priv *a_priv = board->private_data;
815 struct usb_device *usb_dev;
816 struct agilent_82357a_register_pairlet write;
817 int retval;
818
819 if (!a_priv->bus_interface)
820 return; //-ENODEV;
821
822 usb_dev = interface_to_usbdev(a_priv->bus_interface);
823 write.address = AUXCR;
824 write.value = AUX_SRE;
825 if (enable)
826 write.value |= AUX_CS;
827 retval = agilent_82357a_write_registers(a_priv, &write, 1);
828 if (retval)
829 dev_err(&usb_dev->dev, "write_registers() returned error\n");
830 a_priv->ren_state = enable;
831 return;// 0;
832 }
833
agilent_82357a_enable_eos(struct gpib_board * board,u8 eos_byte,int compare_8_bits)834 static int agilent_82357a_enable_eos(struct gpib_board *board, u8 eos_byte,
835 int compare_8_bits)
836 {
837 struct agilent_82357a_priv *a_priv = board->private_data;
838
839 if (!a_priv->bus_interface)
840 return -ENODEV;
841 if (compare_8_bits == 0)
842 return -EOPNOTSUPP;
843
844 a_priv->eos_char = eos_byte;
845 a_priv->eos_mode = REOS | BIN;
846 return 0;
847 }
848
agilent_82357a_disable_eos(struct gpib_board * board)849 static void agilent_82357a_disable_eos(struct gpib_board *board)
850 {
851 struct agilent_82357a_priv *a_priv = board->private_data;
852
853 a_priv->eos_mode &= ~REOS;
854 }
855
agilent_82357a_update_status(struct gpib_board * board,unsigned int clear_mask)856 static unsigned int agilent_82357a_update_status(struct gpib_board *board,
857 unsigned int clear_mask)
858 {
859 struct agilent_82357a_priv *a_priv = board->private_data;
860 struct usb_device *usb_dev;
861 struct agilent_82357a_register_pairlet address_status, bus_status;
862 int retval;
863
864 if (!a_priv->bus_interface)
865 return -ENODEV;
866 usb_dev = interface_to_usbdev(a_priv->bus_interface);
867 board->status &= ~clear_mask;
868 if (a_priv->is_cic)
869 set_bit(CIC_NUM, &board->status);
870 else
871 clear_bit(CIC_NUM, &board->status);
872 address_status.address = ADSR;
873 retval = agilent_82357a_read_registers(a_priv, &address_status, 1, 0);
874 if (retval) {
875 if (retval != -EAGAIN)
876 dev_err(&usb_dev->dev, "read_registers() returned error\n");
877 return board->status;
878 }
879 // check for remote/local
880 if (address_status.value & HR_REM)
881 set_bit(REM_NUM, &board->status);
882 else
883 clear_bit(REM_NUM, &board->status);
884 // check for lockout
885 if (address_status.value & HR_LLO)
886 set_bit(LOK_NUM, &board->status);
887 else
888 clear_bit(LOK_NUM, &board->status);
889 // check for ATN
890 if (address_status.value & HR_ATN)
891 set_bit(ATN_NUM, &board->status);
892 else
893 clear_bit(ATN_NUM, &board->status);
894 // check for talker/listener addressed
895 if (address_status.value & HR_TA)
896 set_bit(TACS_NUM, &board->status);
897 else
898 clear_bit(TACS_NUM, &board->status);
899 if (address_status.value & HR_LA)
900 set_bit(LACS_NUM, &board->status);
901 else
902 clear_bit(LACS_NUM, &board->status);
903
904 bus_status.address = BSR;
905 retval = agilent_82357a_read_registers(a_priv, &bus_status, 1, 0);
906 if (retval) {
907 if (retval != -EAGAIN)
908 dev_err(&usb_dev->dev, "read_registers() returned error\n");
909 return board->status;
910 }
911 if (bus_status.value & BSR_SRQ_BIT)
912 set_bit(SRQI_NUM, &board->status);
913 else
914 clear_bit(SRQI_NUM, &board->status);
915
916 return board->status;
917 }
918
agilent_82357a_primary_address(struct gpib_board * board,unsigned int address)919 static int agilent_82357a_primary_address(struct gpib_board *board, unsigned int address)
920 {
921 struct agilent_82357a_priv *a_priv = board->private_data;
922 struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface);
923 struct agilent_82357a_register_pairlet write;
924 int retval;
925
926 if (!a_priv->bus_interface)
927 return -ENODEV;
928 usb_dev = interface_to_usbdev(a_priv->bus_interface);
929 // put primary address in address0
930 write.address = ADR;
931 write.value = address & ADDRESS_MASK;
932 retval = agilent_82357a_write_registers(a_priv, &write, 1);
933 if (retval) {
934 dev_err(&usb_dev->dev, "write_registers() returned error\n");
935 return retval;
936 }
937 return retval;
938 }
939
agilent_82357a_secondary_address(struct gpib_board * board,unsigned int address,int enable)940 static int agilent_82357a_secondary_address(struct gpib_board *board,
941 unsigned int address, int enable)
942 {
943 if (enable)
944 return -EOPNOTSUPP;
945 return 0;
946 }
947
agilent_82357a_parallel_poll(struct gpib_board * board,u8 * result)948 static int agilent_82357a_parallel_poll(struct gpib_board *board, u8 *result)
949 {
950 struct agilent_82357a_priv *a_priv = board->private_data;
951 struct usb_device *usb_dev;
952 struct agilent_82357a_register_pairlet writes[2];
953 struct agilent_82357a_register_pairlet read;
954 int retval;
955
956 if (!a_priv->bus_interface)
957 return -ENODEV;
958 usb_dev = interface_to_usbdev(a_priv->bus_interface);
959 // execute parallel poll
960 writes[0].address = AUXCR;
961 writes[0].value = AUX_CS | AUX_RPP;
962 writes[1].address = HW_CONTROL;
963 writes[1].value = a_priv->hw_control_bits & ~NOT_PARALLEL_POLL;
964 retval = agilent_82357a_write_registers(a_priv, writes, 2);
965 if (retval) {
966 dev_err(&usb_dev->dev, "write_registers() returned error\n");
967 return retval;
968 }
969 udelay(2); // silly, since usb write will take way longer
970 read.address = CPTR;
971 retval = agilent_82357a_read_registers(a_priv, &read, 1, 1);
972 if (retval) {
973 dev_err(&usb_dev->dev, "read_registers() returned error\n");
974 return retval;
975 }
976 *result = read.value;
977 // clear parallel poll state
978 writes[0].address = HW_CONTROL;
979 writes[0].value = a_priv->hw_control_bits | NOT_PARALLEL_POLL;
980 writes[1].address = AUXCR;
981 writes[1].value = AUX_RPP;
982 retval = agilent_82357a_write_registers(a_priv, writes, 2);
983 if (retval) {
984 dev_err(&usb_dev->dev, "write_registers() returned error\n");
985 return retval;
986 }
987 return 0;
988 }
989
agilent_82357a_parallel_poll_configure(struct gpib_board * board,u8 config)990 static void agilent_82357a_parallel_poll_configure(struct gpib_board *board, u8 config)
991 {
992 // board can only be system controller
993 return;// 0;
994 }
995
agilent_82357a_parallel_poll_response(struct gpib_board * board,int ist)996 static void agilent_82357a_parallel_poll_response(struct gpib_board *board, int ist)
997 {
998 // board can only be system controller
999 return;// 0;
1000 }
1001
agilent_82357a_serial_poll_response(struct gpib_board * board,u8 status)1002 static void agilent_82357a_serial_poll_response(struct gpib_board *board, u8 status)
1003 {
1004 // board can only be system controller
1005 return;// 0;
1006 }
1007
agilent_82357a_serial_poll_status(struct gpib_board * board)1008 static u8 agilent_82357a_serial_poll_status(struct gpib_board *board)
1009 {
1010 // board can only be system controller
1011 return 0;
1012 }
1013
agilent_82357a_return_to_local(struct gpib_board * board)1014 static void agilent_82357a_return_to_local(struct gpib_board *board)
1015 {
1016 // board can only be system controller
1017 return;// 0;
1018 }
1019
agilent_82357a_line_status(const struct gpib_board * board)1020 static int agilent_82357a_line_status(const struct gpib_board *board)
1021 {
1022 struct agilent_82357a_priv *a_priv = board->private_data;
1023 struct usb_device *usb_dev;
1024 struct agilent_82357a_register_pairlet bus_status;
1025 int retval;
1026 int status = VALID_ALL;
1027
1028 if (!a_priv->bus_interface)
1029 return -ENODEV;
1030 usb_dev = interface_to_usbdev(a_priv->bus_interface);
1031 bus_status.address = BSR;
1032 retval = agilent_82357a_read_registers(a_priv, &bus_status, 1, 0);
1033 if (retval) {
1034 if (retval != -EAGAIN)
1035 dev_err(&usb_dev->dev, "read_registers() returned error\n");
1036 return retval;
1037 }
1038 if (bus_status.value & BSR_REN_BIT)
1039 status |= BUS_REN;
1040 if (bus_status.value & BSR_IFC_BIT)
1041 status |= BUS_IFC;
1042 if (bus_status.value & BSR_SRQ_BIT)
1043 status |= BUS_SRQ;
1044 if (bus_status.value & BSR_EOI_BIT)
1045 status |= BUS_EOI;
1046 if (bus_status.value & BSR_NRFD_BIT)
1047 status |= BUS_NRFD;
1048 if (bus_status.value & BSR_NDAC_BIT)
1049 status |= BUS_NDAC;
1050 if (bus_status.value & BSR_DAV_BIT)
1051 status |= BUS_DAV;
1052 if (bus_status.value & BSR_ATN_BIT)
1053 status |= BUS_ATN;
1054 return status;
1055 }
1056
nanosec_to_fast_talker_bits(unsigned int * nanosec)1057 static unsigned short nanosec_to_fast_talker_bits(unsigned int *nanosec)
1058 {
1059 static const int nanosec_per_bit = 21;
1060 static const int max_value = 0x72;
1061 static const int min_value = 0x11;
1062 unsigned short bits;
1063
1064 bits = (*nanosec + nanosec_per_bit / 2) / nanosec_per_bit;
1065 if (bits < min_value)
1066 bits = min_value;
1067 if (bits > max_value)
1068 bits = max_value;
1069 *nanosec = bits * nanosec_per_bit;
1070 return bits;
1071 }
1072
agilent_82357a_t1_delay(struct gpib_board * board,unsigned int nanosec)1073 static int agilent_82357a_t1_delay(struct gpib_board *board, unsigned int nanosec)
1074 {
1075 struct agilent_82357a_priv *a_priv = board->private_data;
1076 struct usb_device *usb_dev;
1077 struct agilent_82357a_register_pairlet write;
1078 int retval;
1079
1080 if (!a_priv->bus_interface)
1081 return -ENODEV;
1082 usb_dev = interface_to_usbdev(a_priv->bus_interface);
1083 write.address = FAST_TALKER_T1;
1084 write.value = nanosec_to_fast_talker_bits(&nanosec);
1085 retval = agilent_82357a_write_registers(a_priv, &write, 1);
1086 if (retval)
1087 dev_err(&usb_dev->dev, "write_registers() returned error\n");
1088 return nanosec;
1089 }
1090
agilent_82357a_interrupt_complete(struct urb * urb)1091 static void agilent_82357a_interrupt_complete(struct urb *urb)
1092 {
1093 struct gpib_board *board = urb->context;
1094 struct agilent_82357a_priv *a_priv = board->private_data;
1095 struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface);
1096 int retval;
1097 u8 *transfer_buffer = urb->transfer_buffer;
1098 unsigned long interrupt_flags;
1099
1100 switch (urb->status) {
1101 /* success */
1102 case 0:
1103 break;
1104 /* unlinked, don't resubmit */
1105 case -ECONNRESET:
1106 case -ENOENT:
1107 case -ESHUTDOWN:
1108 return;
1109 default: /* other error, resubmit */
1110 retval = usb_submit_urb(a_priv->interrupt_urb, GFP_ATOMIC);
1111 if (retval)
1112 dev_err(&usb_dev->dev, "failed to resubmit interrupt urb\n");
1113 return;
1114 }
1115
1116 interrupt_flags = transfer_buffer[0];
1117 if (test_bit(AIF_READ_COMPLETE_BN, &interrupt_flags))
1118 set_bit(AIF_READ_COMPLETE_BN, &a_priv->interrupt_flags);
1119 if (test_bit(AIF_WRITE_COMPLETE_BN, &interrupt_flags))
1120 set_bit(AIF_WRITE_COMPLETE_BN, &a_priv->interrupt_flags);
1121 if (test_bit(AIF_SRQ_BN, &interrupt_flags))
1122 set_bit(SRQI_NUM, &board->status);
1123
1124 wake_up_interruptible(&board->wait);
1125
1126 retval = usb_submit_urb(a_priv->interrupt_urb, GFP_ATOMIC);
1127 if (retval)
1128 dev_err(&usb_dev->dev, "failed to resubmit interrupt urb\n");
1129 }
1130
agilent_82357a_setup_urbs(struct gpib_board * board)1131 static int agilent_82357a_setup_urbs(struct gpib_board *board)
1132 {
1133 struct agilent_82357a_priv *a_priv = board->private_data;
1134 struct usb_device *usb_dev;
1135 int int_pipe;
1136 int retval;
1137
1138 retval = mutex_lock_interruptible(&a_priv->interrupt_alloc_lock);
1139 if (retval)
1140 return retval;
1141 if (!a_priv->bus_interface) {
1142 retval = -ENODEV;
1143 goto setup_exit;
1144 }
1145
1146 a_priv->interrupt_buffer = kmalloc(INTERRUPT_BUF_LEN, GFP_KERNEL);
1147 if (!a_priv->interrupt_buffer) {
1148 retval = -ENOMEM;
1149 goto setup_exit;
1150 }
1151 a_priv->interrupt_urb = usb_alloc_urb(0, GFP_KERNEL);
1152 if (!a_priv->interrupt_urb) {
1153 retval = -ENOMEM;
1154 goto setup_exit;
1155 }
1156 usb_dev = interface_to_usbdev(a_priv->bus_interface);
1157 int_pipe = usb_rcvintpipe(usb_dev, a_priv->interrupt_in_endpoint);
1158 usb_fill_int_urb(a_priv->interrupt_urb, usb_dev, int_pipe, a_priv->interrupt_buffer,
1159 INTERRUPT_BUF_LEN, &agilent_82357a_interrupt_complete, board, 1);
1160 retval = usb_submit_urb(a_priv->interrupt_urb, GFP_KERNEL);
1161 if (retval) {
1162 usb_free_urb(a_priv->interrupt_urb);
1163 a_priv->interrupt_urb = NULL;
1164 dev_err(&usb_dev->dev, "failed to submit first interrupt urb, retval=%i\n", retval);
1165 goto setup_exit;
1166 }
1167 mutex_unlock(&a_priv->interrupt_alloc_lock);
1168 return 0;
1169
1170 setup_exit:
1171 kfree(a_priv->interrupt_buffer);
1172 mutex_unlock(&a_priv->interrupt_alloc_lock);
1173 return retval;
1174 }
1175
agilent_82357a_cleanup_urbs(struct agilent_82357a_priv * a_priv)1176 static void agilent_82357a_cleanup_urbs(struct agilent_82357a_priv *a_priv)
1177 {
1178 if (a_priv && a_priv->bus_interface) {
1179 if (a_priv->interrupt_urb)
1180 usb_kill_urb(a_priv->interrupt_urb);
1181 if (a_priv->bulk_urb)
1182 usb_kill_urb(a_priv->bulk_urb);
1183 }
1184 };
1185
agilent_82357a_release_urbs(struct agilent_82357a_priv * a_priv)1186 static void agilent_82357a_release_urbs(struct agilent_82357a_priv *a_priv)
1187 {
1188 if (a_priv) {
1189 usb_free_urb(a_priv->interrupt_urb);
1190 a_priv->interrupt_urb = NULL;
1191 kfree(a_priv->interrupt_buffer);
1192 }
1193 }
1194
agilent_82357a_allocate_private(struct gpib_board * board)1195 static int agilent_82357a_allocate_private(struct gpib_board *board)
1196 {
1197 struct agilent_82357a_priv *a_priv;
1198
1199 board->private_data = kzalloc(sizeof(struct agilent_82357a_priv), GFP_KERNEL);
1200 if (!board->private_data)
1201 return -ENOMEM;
1202 a_priv = board->private_data;
1203 mutex_init(&a_priv->bulk_transfer_lock);
1204 mutex_init(&a_priv->bulk_alloc_lock);
1205 mutex_init(&a_priv->control_alloc_lock);
1206 mutex_init(&a_priv->interrupt_alloc_lock);
1207 return 0;
1208 }
1209
agilent_82357a_free_private(struct gpib_board * board)1210 static void agilent_82357a_free_private(struct gpib_board *board)
1211 {
1212 kfree(board->private_data);
1213 board->private_data = NULL;
1214 }
1215
1216 #define INIT_NUM_REG_WRITES 18
agilent_82357a_init(struct gpib_board * board)1217 static int agilent_82357a_init(struct gpib_board *board)
1218 {
1219 struct agilent_82357a_priv *a_priv = board->private_data;
1220 struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface);
1221 struct agilent_82357a_register_pairlet hw_control;
1222 struct agilent_82357a_register_pairlet writes[INIT_NUM_REG_WRITES];
1223 int retval;
1224 unsigned int nanosec;
1225
1226 writes[0].address = LED_CONTROL;
1227 writes[0].value = FAIL_LED_ON;
1228 writes[1].address = RESET_TO_POWERUP;
1229 writes[1].value = RESET_SPACEBALL;
1230 retval = agilent_82357a_write_registers(a_priv, writes, 2);
1231 if (retval) {
1232 dev_err(&usb_dev->dev, "write_registers() returned error\n");
1233 return -EIO;
1234 }
1235 set_current_state(TASK_INTERRUPTIBLE);
1236 if (schedule_timeout(usec_to_jiffies(2000)))
1237 return -ERESTARTSYS;
1238 writes[0].address = AUXCR;
1239 writes[0].value = AUX_NBAF;
1240 writes[1].address = AUXCR;
1241 writes[1].value = AUX_HLDE;
1242 writes[2].address = AUXCR;
1243 writes[2].value = AUX_TON;
1244 writes[3].address = AUXCR;
1245 writes[3].value = AUX_LON;
1246 writes[4].address = AUXCR;
1247 writes[4].value = AUX_RSV2;
1248 writes[5].address = AUXCR;
1249 writes[5].value = AUX_INVAL;
1250 writes[6].address = AUXCR;
1251 writes[6].value = AUX_RPP;
1252 writes[7].address = AUXCR;
1253 writes[7].value = AUX_STDL;
1254 writes[8].address = AUXCR;
1255 writes[8].value = AUX_VSTDL;
1256 writes[9].address = FAST_TALKER_T1;
1257 nanosec = board->t1_nano_sec;
1258 writes[9].value = nanosec_to_fast_talker_bits(&nanosec);
1259 board->t1_nano_sec = nanosec;
1260 writes[10].address = ADR;
1261 writes[10].value = board->pad & ADDRESS_MASK;
1262 writes[11].address = PPR;
1263 writes[11].value = 0;
1264 writes[12].address = SPMR;
1265 writes[12].value = 0;
1266 writes[13].address = PROTOCOL_CONTROL;
1267 writes[13].value = WRITE_COMPLETE_INTERRUPT_EN;
1268 writes[14].address = IMR0;
1269 writes[14].value = HR_BOIE | HR_BIIE;
1270 writes[15].address = IMR1;
1271 writes[15].value = HR_SRQIE;
1272 // turn off reset state
1273 writes[16].address = AUXCR;
1274 writes[16].value = AUX_CHIP_RESET;
1275 writes[17].address = LED_CONTROL;
1276 writes[17].value = FIRMWARE_LED_CONTROL;
1277 retval = agilent_82357a_write_registers(a_priv, writes, INIT_NUM_REG_WRITES);
1278 if (retval) {
1279 dev_err(&usb_dev->dev, "write_registers() returned error\n");
1280 return -EIO;
1281 }
1282 hw_control.address = HW_CONTROL;
1283 retval = agilent_82357a_read_registers(a_priv, &hw_control, 1, 1);
1284 if (retval) {
1285 dev_err(&usb_dev->dev, "read_registers() returned error\n");
1286 return -EIO;
1287 }
1288 a_priv->hw_control_bits = (hw_control.value & ~0x7) | NOT_TI_RESET | NOT_PARALLEL_POLL;
1289
1290 return 0;
1291 }
1292
agilent_82357a_device_match(struct usb_interface * interface,const struct gpib_board_config * config)1293 static inline int agilent_82357a_device_match(struct usb_interface *interface,
1294 const struct gpib_board_config *config)
1295 {
1296 struct usb_device * const usbdev = interface_to_usbdev(interface);
1297
1298 if (gpib_match_device_path(&interface->dev, config->device_path) == 0)
1299 return 0;
1300 if (config->serial_number &&
1301 strcmp(usbdev->serial, config->serial_number) != 0)
1302 return 0;
1303
1304 return 1;
1305 }
1306
agilent_82357a_attach(struct gpib_board * board,const struct gpib_board_config * config)1307 static int agilent_82357a_attach(struct gpib_board *board, const struct gpib_board_config *config)
1308 {
1309 int retval;
1310 int i;
1311 unsigned int product_id;
1312 struct agilent_82357a_priv *a_priv;
1313 struct usb_device *usb_dev;
1314
1315 if (mutex_lock_interruptible(&agilent_82357a_hotplug_lock))
1316 return -ERESTARTSYS;
1317
1318 retval = agilent_82357a_allocate_private(board);
1319 if (retval < 0) {
1320 mutex_unlock(&agilent_82357a_hotplug_lock);
1321 return retval;
1322 }
1323 a_priv = board->private_data;
1324 for (i = 0; i < MAX_NUM_82357A_INTERFACES; ++i) {
1325 if (agilent_82357a_driver_interfaces[i] &&
1326 !usb_get_intfdata(agilent_82357a_driver_interfaces[i]) &&
1327 agilent_82357a_device_match(agilent_82357a_driver_interfaces[i], config)) {
1328 a_priv->bus_interface = agilent_82357a_driver_interfaces[i];
1329 usb_set_intfdata(agilent_82357a_driver_interfaces[i], board);
1330 usb_dev = interface_to_usbdev(a_priv->bus_interface);
1331 break;
1332 }
1333 }
1334 if (i == MAX_NUM_82357A_INTERFACES) {
1335 dev_err(board->gpib_dev,
1336 "No supported adapters found, have you loaded its firmware?\n");
1337 retval = -ENODEV;
1338 goto attach_fail;
1339 }
1340 product_id = le16_to_cpu(interface_to_usbdev(a_priv->bus_interface)->descriptor.idProduct);
1341 switch (product_id) {
1342 case USB_DEVICE_ID_AGILENT_82357A:
1343 a_priv->bulk_out_endpoint = AGILENT_82357A_BULK_OUT_ENDPOINT;
1344 a_priv->interrupt_in_endpoint = AGILENT_82357A_INTERRUPT_IN_ENDPOINT;
1345 break;
1346 case USB_DEVICE_ID_AGILENT_82357B:
1347 a_priv->bulk_out_endpoint = AGILENT_82357B_BULK_OUT_ENDPOINT;
1348 a_priv->interrupt_in_endpoint = AGILENT_82357B_INTERRUPT_IN_ENDPOINT;
1349 break;
1350 default:
1351 dev_err(&usb_dev->dev, "bug, unhandled product_id in switch?\n");
1352 retval = -EIO;
1353 goto attach_fail;
1354 }
1355
1356 retval = agilent_82357a_setup_urbs(board);
1357 if (retval < 0)
1358 goto attach_fail;
1359
1360 timer_setup(&a_priv->bulk_timer, agilent_82357a_timeout_handler, 0);
1361
1362 board->t1_nano_sec = 800;
1363
1364 retval = agilent_82357a_init(board);
1365
1366 if (retval < 0) {
1367 agilent_82357a_cleanup_urbs(a_priv);
1368 agilent_82357a_release_urbs(a_priv);
1369 goto attach_fail;
1370 }
1371
1372 dev_info(&usb_dev->dev, "bus %d dev num %d attached to gpib%d, interface %i\n",
1373 usb_dev->bus->busnum, usb_dev->devnum, board->minor, i);
1374 mutex_unlock(&agilent_82357a_hotplug_lock);
1375 return retval;
1376
1377 attach_fail:
1378 agilent_82357a_free_private(board);
1379 mutex_unlock(&agilent_82357a_hotplug_lock);
1380 return retval;
1381 }
1382
agilent_82357a_go_idle(struct gpib_board * board)1383 static int agilent_82357a_go_idle(struct gpib_board *board)
1384 {
1385 struct agilent_82357a_priv *a_priv = board->private_data;
1386 struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface);
1387 struct agilent_82357a_register_pairlet writes[0x20];
1388 int retval;
1389
1390 // turn on tms9914 reset state
1391 writes[0].address = AUXCR;
1392 writes[0].value = AUX_CS | AUX_CHIP_RESET;
1393 a_priv->hw_control_bits &= ~NOT_TI_RESET;
1394 writes[1].address = HW_CONTROL;
1395 writes[1].value = a_priv->hw_control_bits;
1396 writes[2].address = PROTOCOL_CONTROL;
1397 writes[2].value = 0;
1398 writes[3].address = IMR0;
1399 writes[3].value = 0;
1400 writes[4].address = IMR1;
1401 writes[4].value = 0;
1402 writes[5].address = LED_CONTROL;
1403 writes[5].value = 0;
1404 retval = agilent_82357a_write_registers(a_priv, writes, 6);
1405 if (retval) {
1406 dev_err(&usb_dev->dev, "write_registers() returned error\n");
1407 return -EIO;
1408 }
1409 return 0;
1410 }
1411
agilent_82357a_detach(struct gpib_board * board)1412 static void agilent_82357a_detach(struct gpib_board *board)
1413 {
1414 struct agilent_82357a_priv *a_priv;
1415
1416 mutex_lock(&agilent_82357a_hotplug_lock);
1417
1418 a_priv = board->private_data;
1419 if (a_priv) {
1420 if (a_priv->bus_interface) {
1421 agilent_82357a_go_idle(board);
1422 usb_set_intfdata(a_priv->bus_interface, NULL);
1423 }
1424 mutex_lock(&a_priv->control_alloc_lock);
1425 mutex_lock(&a_priv->bulk_alloc_lock);
1426 mutex_lock(&a_priv->interrupt_alloc_lock);
1427 agilent_82357a_cleanup_urbs(a_priv);
1428 agilent_82357a_release_urbs(a_priv);
1429 agilent_82357a_free_private(board);
1430 }
1431 mutex_unlock(&agilent_82357a_hotplug_lock);
1432 }
1433
1434 static struct gpib_interface agilent_82357a_gpib_interface = {
1435 .name = "agilent_82357a",
1436 .attach = agilent_82357a_attach,
1437 .detach = agilent_82357a_detach,
1438 .read = agilent_82357a_read,
1439 .write = agilent_82357a_write,
1440 .command = agilent_82357a_command,
1441 .take_control = agilent_82357a_take_control,
1442 .go_to_standby = agilent_82357a_go_to_standby,
1443 .request_system_control = agilent_82357a_request_system_control,
1444 .interface_clear = agilent_82357a_interface_clear,
1445 .remote_enable = agilent_82357a_remote_enable,
1446 .enable_eos = agilent_82357a_enable_eos,
1447 .disable_eos = agilent_82357a_disable_eos,
1448 .parallel_poll = agilent_82357a_parallel_poll,
1449 .parallel_poll_configure = agilent_82357a_parallel_poll_configure,
1450 .parallel_poll_response = agilent_82357a_parallel_poll_response,
1451 .local_parallel_poll_mode = NULL, // XXX
1452 .line_status = agilent_82357a_line_status,
1453 .update_status = agilent_82357a_update_status,
1454 .primary_address = agilent_82357a_primary_address,
1455 .secondary_address = agilent_82357a_secondary_address,
1456 .serial_poll_response = agilent_82357a_serial_poll_response,
1457 .serial_poll_status = agilent_82357a_serial_poll_status,
1458 .t1_delay = agilent_82357a_t1_delay,
1459 .return_to_local = agilent_82357a_return_to_local,
1460 .no_7_bit_eos = 1,
1461 .skip_check_for_command_acceptors = 1
1462 };
1463
1464 // Table with the USB-devices: just now only testing IDs
1465 static struct usb_device_id agilent_82357a_driver_device_table[] = {
1466 {USB_DEVICE(USB_VENDOR_ID_AGILENT, USB_DEVICE_ID_AGILENT_82357A)},
1467 {USB_DEVICE(USB_VENDOR_ID_AGILENT, USB_DEVICE_ID_AGILENT_82357B)},
1468 {} /* Terminating entry */
1469 };
1470 MODULE_DEVICE_TABLE(usb, agilent_82357a_driver_device_table);
1471
agilent_82357a_driver_probe(struct usb_interface * interface,const struct usb_device_id * id)1472 static int agilent_82357a_driver_probe(struct usb_interface *interface,
1473 const struct usb_device_id *id)
1474 {
1475 int i;
1476 char *path;
1477 static const int path_length = 1024;
1478 struct usb_device *usb_dev;
1479
1480 if (mutex_lock_interruptible(&agilent_82357a_hotplug_lock))
1481 return -ERESTARTSYS;
1482 usb_dev = usb_get_dev(interface_to_usbdev(interface));
1483 for (i = 0; i < MAX_NUM_82357A_INTERFACES; ++i) {
1484 if (!agilent_82357a_driver_interfaces[i]) {
1485 agilent_82357a_driver_interfaces[i] = interface;
1486 usb_set_intfdata(interface, NULL);
1487 dev_dbg(&usb_dev->dev, "set bus interface %i to address 0x%p\n",
1488 i, interface);
1489 break;
1490 }
1491 }
1492 if (i == MAX_NUM_82357A_INTERFACES) {
1493 usb_put_dev(usb_dev);
1494 mutex_unlock(&agilent_82357a_hotplug_lock);
1495 dev_err(&usb_dev->dev, "out of space in agilent_82357a_driver_interfaces[]\n");
1496 return -1;
1497 }
1498 path = kmalloc(path_length, GFP_KERNEL);
1499 if (!path) {
1500 usb_put_dev(usb_dev);
1501 mutex_unlock(&agilent_82357a_hotplug_lock);
1502 return -ENOMEM;
1503 }
1504 usb_make_path(usb_dev, path, path_length);
1505 dev_info(&usb_dev->dev, "probe succeeded for path: %s\n", path);
1506 kfree(path);
1507 mutex_unlock(&agilent_82357a_hotplug_lock);
1508 return 0;
1509 }
1510
agilent_82357a_driver_disconnect(struct usb_interface * interface)1511 static void agilent_82357a_driver_disconnect(struct usb_interface *interface)
1512 {
1513 int i;
1514 struct usb_device *usb_dev = interface_to_usbdev(interface);
1515
1516 mutex_lock(&agilent_82357a_hotplug_lock);
1517
1518 for (i = 0; i < MAX_NUM_82357A_INTERFACES; ++i) {
1519 if (agilent_82357a_driver_interfaces[i] == interface) {
1520 struct gpib_board *board = usb_get_intfdata(interface);
1521
1522 if (board) {
1523 struct agilent_82357a_priv *a_priv = board->private_data;
1524
1525 if (a_priv) {
1526 mutex_lock(&a_priv->control_alloc_lock);
1527 mutex_lock(&a_priv->bulk_alloc_lock);
1528 mutex_lock(&a_priv->interrupt_alloc_lock);
1529 agilent_82357a_cleanup_urbs(a_priv);
1530 a_priv->bus_interface = NULL;
1531 mutex_unlock(&a_priv->interrupt_alloc_lock);
1532 mutex_unlock(&a_priv->bulk_alloc_lock);
1533 mutex_unlock(&a_priv->control_alloc_lock);
1534 }
1535 }
1536 agilent_82357a_driver_interfaces[i] = NULL;
1537 break;
1538 }
1539 }
1540 if (i == MAX_NUM_82357A_INTERFACES)
1541 dev_err(&usb_dev->dev, "unable to find interface - bug?\n");
1542 usb_put_dev(usb_dev);
1543
1544 mutex_unlock(&agilent_82357a_hotplug_lock);
1545 }
1546
agilent_82357a_driver_suspend(struct usb_interface * interface,pm_message_t message)1547 static int agilent_82357a_driver_suspend(struct usb_interface *interface, pm_message_t message)
1548 {
1549 int i, retval;
1550 struct usb_device *usb_dev = interface_to_usbdev(interface);
1551
1552 mutex_lock(&agilent_82357a_hotplug_lock);
1553
1554 for (i = 0; i < MAX_NUM_82357A_INTERFACES; ++i) {
1555 if (agilent_82357a_driver_interfaces[i] == interface) {
1556 struct gpib_board *board = usb_get_intfdata(interface);
1557
1558 if (board) {
1559 struct agilent_82357a_priv *a_priv = board->private_data;
1560
1561 if (a_priv) {
1562 agilent_82357a_abort(a_priv, 0);
1563 agilent_82357a_abort(a_priv, 0);
1564 retval = agilent_82357a_go_idle(board);
1565 if (retval) {
1566 dev_err(&usb_dev->dev, "failed to go idle, retval=%i\n",
1567 retval);
1568 mutex_unlock(&agilent_82357a_hotplug_lock);
1569 return retval;
1570 }
1571 mutex_lock(&a_priv->interrupt_alloc_lock);
1572 agilent_82357a_cleanup_urbs(a_priv);
1573 mutex_unlock(&a_priv->interrupt_alloc_lock);
1574 dev_dbg(&usb_dev->dev,
1575 "bus %d dev num %d gpib %d, interface %i suspended\n",
1576 usb_dev->bus->busnum, usb_dev->devnum,
1577 board->minor, i);
1578 }
1579 }
1580 break;
1581 }
1582 }
1583
1584 mutex_unlock(&agilent_82357a_hotplug_lock);
1585
1586 return 0;
1587 }
1588
agilent_82357a_driver_resume(struct usb_interface * interface)1589 static int agilent_82357a_driver_resume(struct usb_interface *interface)
1590 {
1591 struct usb_device *usb_dev = interface_to_usbdev(interface);
1592 struct gpib_board *board;
1593 int i, retval = 0;
1594
1595 mutex_lock(&agilent_82357a_hotplug_lock);
1596
1597 for (i = 0; i < MAX_NUM_82357A_INTERFACES; ++i) {
1598 if (agilent_82357a_driver_interfaces[i] == interface) {
1599 board = usb_get_intfdata(interface);
1600 if (board)
1601 break;
1602 }
1603 }
1604 if (i == MAX_NUM_82357A_INTERFACES) {
1605 retval = -ENOENT;
1606 goto resume_exit;
1607 }
1608
1609 struct agilent_82357a_priv *a_priv = board->private_data;
1610
1611 if (a_priv) {
1612 if (a_priv->interrupt_urb) {
1613 mutex_lock(&a_priv->interrupt_alloc_lock);
1614 retval = usb_submit_urb(a_priv->interrupt_urb, GFP_KERNEL);
1615 if (retval) {
1616 dev_err(&usb_dev->dev, "failed to resubmit interrupt urb in resume, retval=%i\n",
1617 retval);
1618 mutex_unlock(&a_priv->interrupt_alloc_lock);
1619 mutex_unlock(&agilent_82357a_hotplug_lock);
1620 return retval;
1621 }
1622 mutex_unlock(&a_priv->interrupt_alloc_lock);
1623 }
1624 retval = agilent_82357a_init(board);
1625 if (retval < 0) {
1626 mutex_unlock(&agilent_82357a_hotplug_lock);
1627 return retval;
1628 }
1629 // set/unset system controller
1630 retval = agilent_82357a_request_system_control(board, board->master);
1631 // toggle ifc if master
1632 if (board->master) {
1633 agilent_82357a_interface_clear(board, 1);
1634 usleep_range(200, 250);
1635 agilent_82357a_interface_clear(board, 0);
1636 }
1637 // assert/unassert REN
1638 agilent_82357a_remote_enable(board, a_priv->ren_state);
1639
1640 dev_dbg(&usb_dev->dev,
1641 "bus %d dev num %d gpib%d, interface %i resumed\n",
1642 usb_dev->bus->busnum, usb_dev->devnum, board->minor, i);
1643 }
1644
1645 resume_exit:
1646 mutex_unlock(&agilent_82357a_hotplug_lock);
1647
1648 return retval;
1649 }
1650
1651 static struct usb_driver agilent_82357a_bus_driver = {
1652 .name = DRV_NAME,
1653 .probe = agilent_82357a_driver_probe,
1654 .disconnect = agilent_82357a_driver_disconnect,
1655 .suspend = agilent_82357a_driver_suspend,
1656 .resume = agilent_82357a_driver_resume,
1657 .id_table = agilent_82357a_driver_device_table,
1658 };
1659
agilent_82357a_init_module(void)1660 static int __init agilent_82357a_init_module(void)
1661 {
1662 int i;
1663 int ret;
1664
1665 for (i = 0; i < MAX_NUM_82357A_INTERFACES; ++i)
1666 agilent_82357a_driver_interfaces[i] = NULL;
1667
1668 ret = usb_register(&agilent_82357a_bus_driver);
1669 if (ret) {
1670 pr_err("usb_register failed: error = %d\n", ret);
1671 return ret;
1672 }
1673
1674 ret = gpib_register_driver(&agilent_82357a_gpib_interface, THIS_MODULE);
1675 if (ret) {
1676 pr_err("gpib_register_driver failed: error = %d\n", ret);
1677 usb_deregister(&agilent_82357a_bus_driver);
1678 return ret;
1679 }
1680
1681 return 0;
1682 }
1683
agilent_82357a_exit_module(void)1684 static void __exit agilent_82357a_exit_module(void)
1685 {
1686 gpib_unregister_driver(&agilent_82357a_gpib_interface);
1687 usb_deregister(&agilent_82357a_bus_driver);
1688 }
1689
1690 module_init(agilent_82357a_init_module);
1691 module_exit(agilent_82357a_exit_module);
1692