Lines Matching defs:dev
195 void *dev; /* back pointer to s2255_dev struct*/
205 struct s2255_dev *dev;
335 static int s2255_start_readpipe(struct s2255_dev *dev);
336 static void s2255_stop_readpipe(struct s2255_dev *dev);
342 static int s2255_board_shutdown(struct s2255_dev *dev);
343 static void s2255_fwload_start(struct s2255_dev *dev);
344 static void s2255_destroy(struct s2255_dev *dev);
345 static long s2255_vendor_req(struct s2255_dev *dev, unsigned char req,
351 #define s2255_dev_err(dev, fmt, arg...) \
352 dev_err(dev, S2255_DRIVER_NAME " - " fmt, ##arg)
354 #define dprintk(dev, level, fmt, arg...) \
355 v4l2_dbg(level, debug, &dev->v4l2_dev, fmt, ## arg)
360 static int video_nr = -1; /* /dev/videoN, -1 for autodetect */
460 static void s2255_reset_dsppower(struct s2255_dev *dev)
462 s2255_vendor_req(dev, 0x40, 0x0000, 0x0001, NULL, 0, 1);
464 s2255_vendor_req(dev, 0x50, 0x0000, 0x0000, NULL, 0, 1);
466 s2255_vendor_req(dev, 0x10, 0x0000, 0x0000, NULL, 0, 1);
474 struct s2255_dev *dev = from_timer(dev, t, timer);
475 struct s2255_fw *data = dev->fw_data;
495 struct usb_device *udev = urb->dev;
498 dev_err(&udev->dev, "URB failed with status %d\n", urb->status);
505 s2255_dev_err(&udev->dev, "disconnected\n");
530 dev_err(&udev->dev, "failed submit URB\n");
546 struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
551 dprintk(dev, 1, "No active queue to serve\n");
566 dprintk(dev, 2, "%s: [buf] [%p]\n", __func__, buf);
599 struct s2255_dev *dev = vc->dev;
635 dprintk(dev, 2, "s2255fill at : Buffer %p size= %d\n",
665 dprintk(vc->dev, 4, "%s\n", __func__);
673 dprintk(vc->dev, 4, "invalid buffer prepare\n");
678 dprintk(vc->dev, 4, "invalid buffer prepare\n");
692 dprintk(vc->dev, 1, "%s\n", __func__);
715 struct s2255_dev *dev = vc->dev;
719 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
772 dprintk(vc->dev, 50, "%s NTSC: %d suggested width: %d, height: %d\n",
805 dprintk(vc->dev, 50, "%s: set width %d height %d field %d\n", __func__,
830 dprintk(vc->dev, 1, "queue busy\n");
967 struct device *dev = &sdev->udev->dev;
968 dev_info(dev, "------------------------------------------------\n");
969 dev_info(dev, "format: %d\nscale %d\n", mode->format, mode->scale);
970 dev_info(dev, "fdec: %d\ncolor %d\n", mode->fdec, mode->color);
971 dev_info(dev, "bright: 0x%x\n", mode->bright);
972 dev_info(dev, "------------------------------------------------\n");
988 struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
990 __le32 *buffer = dev->cmdbuf;
992 mutex_lock(&dev->cmdlock);
994 dprintk(dev, 3, "%s channel: %d\n", __func__, vc->idx);
1005 dprintk(dev, 1, "%s: reqsize %ld\n", __func__, vc->req_image_size);
1013 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
1015 s2255_print_cfg(dev, mode);
1022 dprintk(dev, 0, "s2255: no set mode response\n");
1028 dprintk(dev, 1, "%s chn %d, result: %d\n", __func__, vc->idx, res);
1029 mutex_unlock(&dev->cmdlock);
1037 struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
1038 __le32 *buffer = dev->cmdbuf;
1040 mutex_lock(&dev->cmdlock);
1042 dprintk(dev, 4, "%s chan %d\n", __func__, vc->idx);
1049 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
1054 dprintk(dev, 0, "s2255: no vidstatus response\n");
1058 dprintk(dev, 4, "%s, vid status %d\n", __func__, *pstatus);
1059 mutex_unlock(&dev->cmdlock);
1090 dprintk(vc->dev, 2, "[%p/%d] done\n",
1111 dprintk(vc->dev, 4, "%s 60 Hz\n", __func__);
1121 dprintk(vc->dev, 4, "%s 50 Hz\n", __func__);
1156 struct s2255_dev *dev = vc->dev;
1164 if (dev->dsp_fw_ver >= S2255_MIN_DSP_STATUS) {
1167 dprintk(dev, 4, "s2255_cmd_status rc: %d status %x\n",
1173 switch (dev->pid) {
1244 dprintk(vc->dev, 2, "%s: quality %d\n", __func__, jc->quality);
1256 dprintk(vc->dev, 2, "%s: quality %d\n", __func__, jc->quality);
1289 dprintk(vc->dev, 4, "%s capture mode, %d timeperframe %d/%d\n",
1331 dprintk(vc->dev, 4, "%s capture mode, %d timeperframe %d/%d, fdec %d\n",
1398 dprintk(vc->dev, 4, "%s discrete %d/%d\n", __func__,
1407 struct s2255_dev *dev = vc->dev;
1415 dprintk(dev, 1, "s2255: %s\n", __func__);
1416 state = atomic_read(&dev->fw_data->fw_state);
1421 s2255_dev_err(&dev->udev->dev,
1423 s2255_fwload_start(dev);
1424 wait_event_timeout(dev->fw_data->wait_fw,
1425 ((atomic_read(&dev->fw_data->fw_state)
1427 (atomic_read(&dev->fw_data->fw_state)
1431 state = atomic_read(&dev->fw_data->fw_state);
1438 wait_event_timeout(dev->fw_data->wait_fw,
1439 ((atomic_read(&dev->fw_data->fw_state)
1441 (atomic_read(&dev->fw_data->fw_state)
1445 state = atomic_read(&dev->fw_data->fw_state);
1470 atomic_set(&dev->fw_data->fw_state,
1486 static void s2255_destroy(struct s2255_dev *dev)
1488 dprintk(dev, 1, "%s", __func__);
1490 s2255_board_shutdown(dev);
1492 del_timer_sync(&dev->timer); /* only started in .probe and .open */
1493 if (dev->fw_data->fw_urb) {
1494 usb_kill_urb(dev->fw_data->fw_urb);
1495 usb_free_urb(dev->fw_data->fw_urb);
1496 dev->fw_data->fw_urb = NULL;
1498 release_firmware(dev->fw_data->fw);
1499 kfree(dev->fw_data->pfw_data);
1500 kfree(dev->fw_data);
1502 s2255_reset_dsppower(dev);
1503 mutex_destroy(&dev->lock);
1504 usb_put_dev(dev->udev);
1505 v4l2_device_unregister(&dev->v4l2_dev);
1506 kfree(dev->cmdbuf);
1507 kfree(dev);
1550 struct s2255_dev *dev = to_s2255_dev(vdev->v4l2_dev);
1554 dprintk(dev, 4, "%s, chnls: %d\n", __func__,
1555 atomic_read(&dev->num_channels));
1559 if (atomic_dec_and_test(&dev->num_channels))
1560 s2255_destroy(dev);
1586 static int s2255_probe_v4l(struct s2255_dev *dev)
1594 ret = v4l2_device_register(&dev->interface->dev, &dev->v4l2_dev);
1600 vc = &dev->vc[i];
1616 if (dev->dsp_fw_ver >= S2255_MIN_DSP_COLORFILTER &&
1617 (dev->pid != 0x2257 || vc->idx <= 1))
1623 dev_err(&dev->udev->dev, "couldn't register control\n");
1637 dev_err(&dev->udev->dev,
1645 vc->vdev.lock = &dev->lock;
1646 vc->vdev.v4l2_dev = &dev->v4l2_dev;
1660 dev_err(&dev->udev->dev,
1664 atomic_inc(&dev->num_channels);
1665 v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1672 if (atomic_read(&dev->num_channels) == 0) {
1673 v4l2_device_unregister(&dev->v4l2_dev);
1676 if (atomic_read(&dev->num_channels) != MAX_CHANNELS)
1692 static int save_frame(struct s2255_dev *dev, struct s2255_pipeinfo *pipe_info)
1704 dprintk(dev, 100, "buffer to user\n");
1705 vc = &dev->vc[dev->cc];
1719 dprintk(dev, 4, "marker @ offset: %d [%x %x]\n",
1725 dprintk(dev, 0,
1730 dev->cc = G_chnmap[cc];
1731 vc = &dev->vc[dev->cc];
1750 vc = &dev->vc[cc];
1757 dprintk(dev, 5, "setmode rdy %d\n", cc);
1760 dev->chn_ready |= (1 << cc);
1761 if ((dev->chn_ready & 0x0f) != 0x0f)
1765 atomic_set(&dev->fw_data->fw_state,
1767 wake_up(&dev->fw_data->wait_fw);
1773 dprintk(dev, 5, "vstat %x chan %d\n",
1791 vc = &dev->vc[dev->cc];
1811 dprintk(dev, 1, "s2255 frame buffer == NULL.%p %p %d %d",
1812 frm, dev, dev->cc, idx);
1827 dprintk(dev, 4, "cur_size: %lu, size: %lu\n", frm->cur_size, size);
1830 dprintk(dev, 2, "******[%d]Buffer[%d]full*******\n",
1831 dev->cc, idx);
1850 static void s2255_read_video_callback(struct s2255_dev *dev,
1854 dprintk(dev, 50, "callback read video\n");
1856 if (dev->cc >= MAX_CHANNELS) {
1857 dev->cc = 0;
1858 dev_err(&dev->udev->dev, "invalid channel\n");
1862 res = save_frame(dev, pipe_info);
1864 dprintk(dev, 4, "s2255: read callback failed\n");
1866 dprintk(dev, 50, "callback read video done\n");
1870 static long s2255_vendor_req(struct s2255_dev *dev, unsigned char Request,
1882 r = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
1893 r = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
1904 * @param dev pointer to device extension
1907 static int s2255_get_fx2fw(struct s2255_dev *dev)
1912 ret = s2255_vendor_req(dev, S2255_VR_FW, 0, 0, transBuffer, 2,
1915 dprintk(dev, 2, "get fw error: %x\n", ret);
1917 dprintk(dev, 2, "Get FW %x %x\n", transBuffer[0], transBuffer[1]);
1968 static int s2255_board_init(struct s2255_dev *dev)
1973 struct s2255_pipeinfo *pipe = &dev->pipe;
1974 dprintk(dev, 4, "board init: %p", dev);
1976 pipe->dev = dev;
1983 dprintk(dev, 1, "out of memory!\n");
1987 fw_ver = s2255_get_fx2fw(dev);
1997 struct s2255_vc *vc = &dev->vc[j];
1999 if (dev->pid == 0x2257 && j > 1)
2013 s2255_start_readpipe(dev);
2014 dprintk(dev, 1, "%s: success\n", __func__);
2018 static int s2255_board_shutdown(struct s2255_dev *dev)
2021 dprintk(dev, 1, "%s: dev: %p", __func__, dev);
2024 if (vb2_is_streaming(&dev->vc[i].vb_vidq))
2025 s2255_stop_acquire(&dev->vc[i]);
2027 s2255_stop_readpipe(dev);
2029 s2255_release_sys_buffers(&dev->vc[i]);
2031 kfree(dev->pipe.transfer_buffer);
2038 struct s2255_dev *dev;
2043 dev_err(&purb->dev->dev, "no context!\n");
2046 dev = pipe_info->dev;
2047 if (dev == NULL) {
2048 dev_err(&purb->dev->dev, "no context!\n");
2054 dprintk(dev, 2, "%s: err shutdown\n", __func__);
2060 dprintk(dev, 2, "%s: exiting USB pipe", __func__);
2065 s2255_read_video_callback(dev, pipe_info);
2068 dprintk(dev, 1, "%s: failed URB %d\n", __func__, status);
2071 pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2073 usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2081 dev_err(&dev->udev->dev, "error submitting urb\n");
2083 dprintk(dev, 2, "%s :complete state 0\n", __func__);
2088 static int s2255_start_readpipe(struct s2255_dev *dev)
2092 struct s2255_pipeinfo *pipe_info = &dev->pipe;
2093 pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2094 dprintk(dev, 2, "%s: IN %d\n", __func__, dev->read_endpoint);
2101 usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2120 struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
2121 __le32 *buffer = dev->cmdbuf;
2123 mutex_lock(&dev->cmdlock);
2137 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2139 dev_err(&dev->udev->dev, "CMD_START error\n");
2141 dprintk(dev, 2, "start acquire exit[%d] %d\n", vc->idx, res);
2142 mutex_unlock(&dev->cmdlock);
2150 struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
2151 __le32 *buffer = dev->cmdbuf;
2153 mutex_lock(&dev->cmdlock);
2160 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2162 dev_err(&dev->udev->dev, "CMD_STOP error\n");
2164 dprintk(dev, 4, "%s: chn %d, res %d\n", __func__, vc->idx, res);
2165 mutex_unlock(&dev->cmdlock);
2169 static void s2255_stop_readpipe(struct s2255_dev *dev)
2171 struct s2255_pipeinfo *pipe = &dev->pipe;
2180 dprintk(dev, 4, "%s", __func__);
2184 static void s2255_fwload_start(struct s2255_dev *dev)
2186 s2255_reset_dsppower(dev);
2187 dev->fw_data->fw_size = dev->fw_data->fw->size;
2188 atomic_set(&dev->fw_data->fw_state, S2255_FW_NOTLOADED);
2189 memcpy(dev->fw_data->pfw_data,
2190 dev->fw_data->fw->data, CHUNK_SIZE);
2191 dev->fw_data->fw_loaded = CHUNK_SIZE;
2192 usb_fill_bulk_urb(dev->fw_data->fw_urb, dev->udev,
2193 usb_sndbulkpipe(dev->udev, 2),
2194 dev->fw_data->pfw_data,
2196 dev->fw_data);
2197 mod_timer(&dev->timer, jiffies + HZ);
2204 struct s2255_dev *dev = NULL;
2213 dev = kzalloc(sizeof(struct s2255_dev), GFP_KERNEL);
2214 if (dev == NULL) {
2215 s2255_dev_err(&interface->dev, "out of memory\n");
2219 dev->cmdbuf = kzalloc(S2255_CMDBUF_SIZE, GFP_KERNEL);
2220 if (dev->cmdbuf == NULL) {
2221 s2255_dev_err(&interface->dev, "out of memory\n");
2225 atomic_set(&dev->num_channels, 0);
2226 dev->pid = id->idProduct;
2227 dev->fw_data = kzalloc(sizeof(struct s2255_fw), GFP_KERNEL);
2228 if (!dev->fw_data)
2230 mutex_init(&dev->lock);
2231 mutex_init(&dev->cmdlock);
2233 dev->udev = usb_get_dev(interface_to_usbdev(interface));
2234 if (dev->udev == NULL) {
2235 dev_err(&interface->dev, "null usb device\n");
2239 dev_dbg(&interface->dev, "dev: %p, udev %p interface %p\n",
2240 dev, dev->udev, interface);
2241 dev->interface = interface;
2244 dev_dbg(&interface->dev, "num EP: %d\n",
2248 if (!dev->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
2250 dev->read_endpoint = endpoint->bEndpointAddress;
2254 if (!dev->read_endpoint) {
2255 dev_err(&interface->dev, "Could not find bulk-in endpoint\n");
2258 timer_setup(&dev->timer, s2255_timer, 0);
2259 init_waitqueue_head(&dev->fw_data->wait_fw);
2261 struct s2255_vc *vc = &dev->vc[i];
2263 vc->dev = dev;
2270 dev->fw_data->fw_urb = usb_alloc_urb(0, GFP_KERNEL);
2271 if (!dev->fw_data->fw_urb)
2274 dev->fw_data->pfw_data = kzalloc(CHUNK_SIZE, GFP_KERNEL);
2275 if (!dev->fw_data->pfw_data) {
2276 dev_err(&interface->dev, "out of memory!\n");
2280 if (request_firmware(&dev->fw_data->fw,
2281 FIRMWARE_FILE_NAME, &dev->udev->dev)) {
2282 dev_err(&interface->dev, "sensoray 2255 failed to get firmware\n");
2286 fw_size = dev->fw_data->fw->size;
2287 pdata = (__le32 *) &dev->fw_data->fw->data[fw_size - 8];
2290 dev_err(&interface->dev, "Firmware invalid.\n");
2296 pRel = (__le32 *) &dev->fw_data->fw->data[fw_size - 4];
2298 dev->dsp_fw_ver = le32_to_cpu(*pRel);
2299 if (dev->dsp_fw_ver < S2255_CUR_DSP_FWVER)
2301 if (dev->pid == 0x2257 &&
2302 dev->dsp_fw_ver < S2255_MIN_DSP_COLORFILTER)
2306 usb_reset_device(dev->udev);
2308 retval = s2255_board_init(dev);
2311 s2255_fwload_start(dev);
2313 retval = s2255_probe_v4l(dev);
2316 dev_info(&interface->dev, "Sensoray 2255 detected\n");
2319 s2255_board_shutdown(dev);
2321 release_firmware(dev->fw_data->fw);
2323 kfree(dev->fw_data->pfw_data);
2325 usb_free_urb(dev->fw_data->fw_urb);
2327 del_timer_sync(&dev->timer);
2329 usb_put_dev(dev->udev);
2331 kfree(dev->fw_data);
2332 mutex_destroy(&dev->lock);
2334 kfree(dev->cmdbuf);
2335 kfree(dev);
2343 struct s2255_dev *dev = to_s2255_dev(usb_get_intfdata(interface));
2345 int channels = atomic_read(&dev->num_channels);
2346 mutex_lock(&dev->lock);
2347 v4l2_device_disconnect(&dev->v4l2_dev);
2348 mutex_unlock(&dev->lock);
2350 atomic_inc(&dev->num_channels);
2353 video_unregister_device(&dev->vc[i].vdev);
2355 atomic_set(&dev->fw_data->fw_state, S2255_FW_DISCONNECTING);
2356 wake_up(&dev->fw_data->wait_fw);
2358 dev->vc[i].setmode_ready = 1;
2359 wake_up(&dev->vc[i].wait_setmode);
2360 dev->vc[i].vidstatus_ready = 1;
2361 wake_up(&dev->vc[i].wait_vidstatus);
2363 if (atomic_dec_and_test(&dev->num_channels))
2364 s2255_destroy(dev);
2365 dev_info(&interface->dev, "%s\n", __func__);