Lines Matching refs:data
70 /* This structure holds private data for each USBTMC device. One copy is
89 /* data for interrupt in endpoint handling */
117 * This structure holds private data for each USBTMC file handle.
120 struct usbtmc_device_data *data;
138 /* data for generic_write */
143 /* data for generic_read */
157 struct usbtmc_device_data *data = to_usbtmc_data(kref);
159 usb_put_dev(data->usb_dev);
160 kfree(data);
166 struct usbtmc_device_data *data;
185 data = usb_get_intfdata(intf);
186 /* Protect reference to data from file structure until release */
187 kref_get(&data->kref);
189 mutex_lock(&data->io_mutex);
190 file_data->data = data;
201 spin_lock_irq(&data->dev_lock);
202 list_add_tail(&file_data->file_elem, &data->file_list);
203 spin_unlock_irq(&data->dev_lock);
204 mutex_unlock(&data->io_mutex);
206 /* Store pointer in file structure's private data field */
218 struct usbtmc_device_data *data;
225 data = file_data->data;
228 mutex_lock(&data->io_mutex);
240 wake_up_interruptible_all(&data->waitq);
241 mutex_unlock(&data->io_mutex);
251 mutex_lock(&file_data->data->io_mutex);
252 spin_lock_irq(&file_data->data->dev_lock);
256 spin_unlock_irq(&file_data->data->dev_lock);
257 mutex_unlock(&file_data->data->io_mutex);
259 kref_put(&file_data->data->kref, usbtmc_delete);
260 file_data->data = NULL;
265 static int usbtmc_ioctl_abort_bulk_in_tag(struct usbtmc_device_data *data,
274 dev = &data->intf->dev;
279 rv = usb_control_msg(data->usb_dev,
280 usb_rcvctrlpipe(data->usb_dev, 0),
283 tag, data->bulk_in,
325 rv = usb_bulk_msg(data->usb_dev,
326 usb_rcvbulkpipe(data->usb_dev,
327 data->bulk_in),
352 rv = usb_control_msg(data->usb_dev,
353 usb_rcvctrlpipe(data->usb_dev, 0),
356 0, data->bulk_in, buffer, 0x08,
389 static int usbtmc_ioctl_abort_bulk_in(struct usbtmc_device_data *data)
391 return usbtmc_ioctl_abort_bulk_in_tag(data, data->bTag_last_read);
394 static int usbtmc_ioctl_abort_bulk_out_tag(struct usbtmc_device_data *data,
402 dev = &data->intf->dev;
408 rv = usb_control_msg(data->usb_dev,
409 usb_rcvctrlpipe(data->usb_dev, 0),
412 tag, data->bulk_out,
434 rv = usb_control_msg(data->usb_dev,
435 usb_rcvctrlpipe(data->usb_dev, 0),
438 0, data->bulk_out, buffer, 0x08,
459 rv = usb_clear_halt(data->usb_dev,
460 usb_sndbulkpipe(data->usb_dev, data->bulk_out));
473 static int usbtmc_ioctl_abort_bulk_out(struct usbtmc_device_data *data)
475 return usbtmc_ioctl_abort_bulk_out_tag(data, data->bTag_last_write);
481 struct usbtmc_device_data *data = file_data->data;
482 struct device *dev = &data->intf->dev;
490 data->iin_ep_present);
492 spin_lock_irq(&data->dev_lock);
497 spin_unlock_irq(&data->dev_lock);
503 spin_unlock_irq(&data->dev_lock);
509 atomic_set(&data->iin_data_valid, 0);
511 rv = usb_control_msg(data->usb_dev,
512 usb_rcvctrlpipe(data->usb_dev, 0),
515 data->iin_bTag,
516 data->ifnum,
529 if (data->iin_ep_present) {
531 data->waitq,
532 atomic_read(&data->iin_data_valid) != 0,
545 tag = data->bNotify1 & 0x7f;
546 if (tag != data->iin_bTag) {
548 data->iin_bTag, tag);
551 stb = data->bNotify2;
561 data->iin_bTag += 1;
562 if (data->iin_bTag > 127)
564 data->iin_bTag = 2;
573 struct usbtmc_device_data *data = file_data->data;
574 struct device *dev = &data->intf->dev;
579 if (!data->iin_ep_present) {
589 mutex_unlock(&data->io_mutex);
592 data->waitq,
597 mutex_lock(&data->io_mutex);
600 if (atomic_read(&file_data->closing) || data->zombie)
618 static int usbtmc488_ioctl_simple(struct usbtmc_device_data *data,
621 struct device *dev = &data->intf->dev;
627 if (!(data->usb488_caps & USBTMC488_CAPABILITY_SIMPLE))
645 rv = usb_control_msg(data->usb_dev,
646 usb_rcvctrlpipe(data->usb_dev, 0),
650 data->ifnum,
681 struct usbtmc_device_data *data = file_data->data;
691 buffer[1] = data->bTag;
692 buffer[2] = ~data->bTag;
694 retval = usb_bulk_msg(data->usb_dev,
695 usb_sndbulkpipe(data->usb_dev,
696 data->bulk_out),
701 data->bTag_last_write = data->bTag;
704 data->bTag++;
705 if (!data->bTag)
706 data->bTag++;
710 dev_err(&data->intf->dev, "%s returned %d\n",
751 dev_err(&file_data->data->intf->dev,
763 dev_dbg(&file_data->data->intf->dev,
771 wake_up_interruptible(&file_data->data->waitq);
782 dev_dbg(&file_data->data->intf->dev, "%s: returns %d\n", __func__,
793 struct usbtmc_device_data *data = file_data->data;
794 struct device *dev = &data->intf->dev;
816 if ((max_transfer_size % data->wMaxPacketSize) == 0)
817 max_transfer_size += (data->wMaxPacketSize - 1);
819 /* round down to bufsize to avoid truncated data left */
881 usb_fill_bulk_urb(urb, data->usb_dev,
882 usb_rcvbulkpipe(data->usb_dev, data->bulk_in),
1054 dev_err(&file_data->data->intf->dev,
1065 dev_dbg(&file_data->data->intf->dev,
1071 wake_up_interruptible(&file_data->data->waitq);
1080 struct usbtmc_device_data *data = file_data->data;
1092 /* Get pointer to private data structure */
1093 dev = &data->intf->dev;
1177 usb_fill_bulk_urb(urb, data->usb_dev,
1178 usb_sndbulkpipe(data->usb_dev, data->bulk_out),
1282 struct usbtmc_device_data *data = file_data->data;
1294 buffer[1] = data->bTag;
1295 buffer[2] = ~data->bTag;
1308 retval = usb_bulk_msg(data->usb_dev,
1309 usb_sndbulkpipe(data->usb_dev,
1310 data->bulk_out),
1315 data->bTag_last_write = data->bTag;
1318 data->bTag++;
1319 if (!data->bTag)
1320 data->bTag++;
1324 dev_err(&data->intf->dev, "%s returned %d\n",
1334 struct usbtmc_device_data *data;
1344 /* Get pointer to private data structure */
1346 data = file_data->data;
1347 dev = &data->intf->dev;
1353 mutex_lock(&data->io_mutex);
1354 if (data->zombie) {
1368 usbtmc_ioctl_abort_bulk_out(data);
1377 retval = usb_bulk_msg(data->usb_dev,
1378 usb_rcvbulkpipe(data->usb_dev,
1379 data->bulk_in),
1387 data->bTag_last_read = data->bTag;
1391 usbtmc_ioctl_abort_bulk_in(data);
1400 usbtmc_ioctl_abort_bulk_in(data);
1408 usbtmc_ioctl_abort_bulk_in(data);
1412 if (buffer[1] != data->bTag_last_write) {
1414 buffer[1], data->bTag_last_write);
1416 usbtmc_ioctl_abort_bulk_in(data);
1432 dev_err(dev, "Device wants to return more data than requested: %u > %zu\n",
1435 usbtmc_ioctl_abort_bulk_in(data);
1475 mutex_unlock(&data->io_mutex);
1484 struct usbtmc_device_data *data;
1492 data = file_data->data;
1494 mutex_lock(&data->io_mutex);
1496 if (data->zombie) {
1537 buffer[1] = data->bTag;
1538 buffer[2] = ~data->bTag;
1564 dev_dbg(&data->intf->dev, "%s(size:%u align:%u)\n", __func__,
1570 usb_fill_bulk_urb(urb, data->usb_dev,
1571 usb_sndbulkpipe(data->usb_dev, data->bulk_out),
1585 data->bTag_last_write = data->bTag;
1586 data->bTag++;
1588 if (!data->bTag)
1589 data->bTag++;
1604 dev_err(&data->intf->dev,
1605 "Unable to send data, error %d\n", (int)retval);
1607 usbtmc_ioctl_abort_bulk_out(data);
1614 mutex_unlock(&data->io_mutex);
1618 static int usbtmc_ioctl_clear(struct usbtmc_device_data *data)
1626 dev = &data->intf->dev;
1634 rv = usb_control_msg(data->usb_dev,
1635 usb_rcvctrlpipe(data->usb_dev, 0),
1658 rv = usb_control_msg(data->usb_dev,
1659 usb_rcvctrlpipe(data->usb_dev, 0),
1684 rv = usb_bulk_msg(data->usb_dev,
1685 usb_rcvbulkpipe(data->usb_dev,
1686 data->bulk_in),
1719 rv = usb_clear_halt(data->usb_dev,
1720 usb_sndbulkpipe(data->usb_dev, data->bulk_out));
1732 static int usbtmc_ioctl_clear_out_halt(struct usbtmc_device_data *data)
1736 rv = usb_clear_halt(data->usb_dev,
1737 usb_sndbulkpipe(data->usb_dev, data->bulk_out));
1740 dev_err(&data->usb_dev->dev, "%s returned %d\n", __func__, rv);
1744 static int usbtmc_ioctl_clear_in_halt(struct usbtmc_device_data *data)
1748 rv = usb_clear_halt(data->usb_dev,
1749 usb_rcvbulkpipe(data->usb_dev, data->bulk_in));
1752 dev_err(&data->usb_dev->dev, "%s returned %d\n", __func__, rv);
1781 static int get_capabilities(struct usbtmc_device_data *data)
1783 struct device *dev = &data->usb_dev->dev;
1791 rv = usb_control_msg(data->usb_dev, usb_rcvctrlpipe(data->usb_dev, 0),
1811 data->capabilities.interface_capabilities = buffer[4];
1812 data->capabilities.device_capabilities = buffer[5];
1813 data->capabilities.usb488_interface_capabilities = buffer[14];
1814 data->capabilities.usb488_device_capabilities = buffer[15];
1815 data->usb488_caps = (buffer[14] & 0x07) | ((buffer[15] & 0x0f) << 4);
1828 struct usbtmc_device_data *data = usb_get_intfdata(intf); \
1830 return sprintf(buf, "%d\n", data->capabilities.name); \
1848 static int usbtmc_ioctl_indicator_pulse(struct usbtmc_device_data *data)
1854 dev = &data->intf->dev;
1860 rv = usb_control_msg(data->usb_dev,
1861 usb_rcvctrlpipe(data->usb_dev, 0),
1885 static int usbtmc_ioctl_request(struct usbtmc_device_data *data,
1888 struct device *dev = &data->intf->dev;
1912 /* Send control data to device */
1913 res = copy_from_user(buffer, request.data,
1923 pipe = usb_rcvctrlpipe(data->usb_dev, 0);
1925 pipe = usb_sndctrlpipe(data->usb_dev, 0);
1926 rv = usb_control_msg(data->usb_dev,
1940 /* Read control data from device */
1941 res = copy_to_user(request.data, buffer, rv);
2018 !(file_data->data->capabilities.device_capabilities & 1)))
2030 struct usbtmc_device_data *data;
2035 data = file_data->data;
2037 mutex_lock(&data->io_mutex);
2038 if (data->zombie) {
2045 retval = usbtmc_ioctl_clear_out_halt(data);
2049 retval = usbtmc_ioctl_clear_in_halt(data);
2053 retval = usbtmc_ioctl_indicator_pulse(data);
2057 retval = usbtmc_ioctl_clear(data);
2061 retval = usbtmc_ioctl_abort_bulk_out(data);
2065 retval = usbtmc_ioctl_abort_bulk_in(data);
2069 retval = usbtmc_ioctl_request(data, (void __user *)arg);
2113 retval = put_user(data->usb488_caps,
2123 retval = usbtmc488_ioctl_simple(data, (void __user *)arg,
2128 retval = usbtmc488_ioctl_simple(data, (void __user *)arg,
2133 retval = usbtmc488_ioctl_simple(data, (void __user *)arg,
2167 mutex_unlock(&data->io_mutex);
2175 return fasync_helper(fd, file, on, &file_data->data->fasync);
2181 struct usbtmc_device_data *data = file_data->data;
2184 mutex_lock(&data->io_mutex);
2186 if (data->zombie) {
2191 poll_wait(file, &data->waitq, wait);
2194 * EPOLLIN|EPOLLRDNORM to normal read data.
2214 dev_dbg(&data->intf->dev, "poll mask = %x\n", mask);
2217 mutex_unlock(&data->io_mutex);
2243 struct usbtmc_device_data *data = urb->context;
2244 struct device *dev = &data->intf->dev;
2248 dev_dbg(&data->intf->dev, "int status: %d len %d\n",
2254 if (data->iin_buffer[0] > 0x81) {
2255 data->bNotify1 = data->iin_buffer[0];
2256 data->bNotify2 = data->iin_buffer[1];
2257 atomic_set(&data->iin_data_valid, 1);
2258 wake_up_interruptible(&data->waitq);
2262 if (data->iin_buffer[0] == 0x81) {
2266 if (data->fasync)
2267 kill_fasync(&data->fasync,
2270 spin_lock_irqsave(&data->dev_lock, flags);
2271 list_for_each(elem, &data->file_list) {
2277 file_data->srq_byte = data->iin_buffer[1];
2280 spin_unlock_irqrestore(&data->dev_lock, flags);
2283 (unsigned int)data->iin_buffer[0],
2284 (unsigned int)data->iin_buffer[1]);
2285 wake_up_interruptible_all(&data->waitq);
2289 data->iin_buffer[0]);
2293 data->iin_wMaxPacketSize, urb->actual_length);
2306 static void usbtmc_free_int(struct usbtmc_device_data *data)
2308 if (!data->iin_ep_present || !data->iin_urb)
2310 usb_kill_urb(data->iin_urb);
2311 kfree(data->iin_buffer);
2312 data->iin_buffer = NULL;
2313 usb_free_urb(data->iin_urb);
2314 data->iin_urb = NULL;
2315 kref_put(&data->kref, usbtmc_delete);
2321 struct usbtmc_device_data *data;
2328 data = kzalloc(sizeof(*data), GFP_KERNEL);
2329 if (!data)
2332 data->intf = intf;
2333 data->id = id;
2334 data->usb_dev = usb_get_dev(interface_to_usbdev(intf));
2335 usb_set_intfdata(intf, data);
2336 kref_init(&data->kref);
2337 mutex_init(&data->io_mutex);
2338 init_waitqueue_head(&data->waitq);
2339 atomic_set(&data->iin_data_valid, 0);
2340 INIT_LIST_HEAD(&data->file_list);
2341 spin_lock_init(&data->dev_lock);
2343 data->zombie = 0;
2346 data->bTag = 1;
2348 data->iin_bTag = 2;
2351 iface_desc = data->intf->cur_altsetting;
2352 data->ifnum = iface_desc->desc.bInterfaceNumber;
2363 data->bulk_in = bulk_in->bEndpointAddress;
2364 data->wMaxPacketSize = usb_endpoint_maxp(bulk_in);
2365 if (!data->wMaxPacketSize)
2367 dev_dbg(&intf->dev, "Found bulk in endpoint at %u\n", data->bulk_in);
2369 data->bulk_out = bulk_out->bEndpointAddress;
2370 dev_dbg(&intf->dev, "Found Bulk out endpoint at %u\n", data->bulk_out);
2375 data->iin_ep_present = 1;
2376 data->iin_ep = int_in->bEndpointAddress;
2377 data->iin_wMaxPacketSize = usb_endpoint_maxp(int_in);
2378 data->iin_interval = int_in->bInterval;
2380 data->iin_ep);
2383 retcode = get_capabilities(data);
2387 if (data->iin_ep_present) {
2389 data->iin_urb = usb_alloc_urb(0, GFP_KERNEL);
2390 if (!data->iin_urb) {
2395 /* Protect interrupt in endpoint data until iin_urb is freed */
2396 kref_get(&data->kref);
2399 data->iin_buffer = kmalloc(data->iin_wMaxPacketSize,
2401 if (!data->iin_buffer) {
2407 usb_fill_int_urb(data->iin_urb, data->usb_dev,
2408 usb_rcvintpipe(data->usb_dev, data->iin_ep),
2409 data->iin_buffer, data->iin_wMaxPacketSize,
2411 data, data->iin_interval);
2413 retcode = usb_submit_urb(data->iin_urb, GFP_KERNEL);
2432 usbtmc_free_int(data);
2434 kref_put(&data->kref, usbtmc_delete);
2440 struct usbtmc_device_data *data = usb_get_intfdata(intf);
2444 mutex_lock(&data->io_mutex);
2445 data->zombie = 1;
2446 wake_up_interruptible_all(&data->waitq);
2447 list_for_each(elem, &data->file_list) {
2456 mutex_unlock(&data->io_mutex);
2457 usbtmc_free_int(data);
2458 kref_put(&data->kref, usbtmc_delete);
2473 struct usbtmc_device_data *data = usb_get_intfdata(intf);
2476 if (!data)
2479 mutex_lock(&data->io_mutex);
2480 list_for_each(elem, &data->file_list) {
2489 if (data->iin_ep_present && data->iin_urb)
2490 usb_kill_urb(data->iin_urb);
2492 mutex_unlock(&data->io_mutex);
2498 struct usbtmc_device_data *data = usb_get_intfdata(intf);
2501 if (data->iin_ep_present && data->iin_urb)
2502 retcode = usb_submit_urb(data->iin_urb, GFP_KERNEL);
2511 struct usbtmc_device_data *data = usb_get_intfdata(intf);
2514 if (!data)
2517 mutex_lock(&data->io_mutex);
2519 list_for_each(elem, &data->file_list) {
2533 struct usbtmc_device_data *data = usb_get_intfdata(intf);
2535 mutex_unlock(&data->io_mutex);