00001
00034 #include <linux/module.h>
00035 #include <linux/init.h>
00036 #include <linux/kernel.h>
00037 #include <linux/version.h>
00038 #include <linux/errno.h>
00039 #include <linux/slab.h>
00040 #include <linux/kref.h>
00041 #include <linux/vmalloc.h>
00042 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
00043 #include <linux/mm.h>
00044 #endif
00045
00046 #include <linux/usb.h>
00047 #include <media/v4l2-common.h>
00048
00049 #include "stk11xx.h"
00050
00051
00056 static int default_nbrframebuf = 3;
00057
00058
00068 void * stk11xx_rvmalloc(unsigned long size)
00069 {
00070 void *mem;
00071 unsigned long addr;
00072
00073 size = PAGE_ALIGN(size);
00074 mem = vmalloc_32(size);
00075
00076 if (!mem)
00077 return NULL;
00078
00079 memset(mem, 0, size);
00080
00081 addr = (unsigned long) mem;
00082
00083 while (size > 0) {
00084 SetPageReserved(vmalloc_to_page((void *) addr));
00085 addr += PAGE_SIZE;
00086 size -= PAGE_SIZE;
00087 }
00088
00089 return mem;
00090 }
00091
00092
00101 void stk11xx_rvfree(void *mem, unsigned long size)
00102 {
00103 unsigned long addr;
00104
00105 if (!mem)
00106 return;
00107
00108 addr = (unsigned long) mem;
00109
00110 while ((long) size > 0) {
00111 ClearPageReserved(vmalloc_to_page((void *) addr));
00112 addr += PAGE_SIZE;
00113 size -= PAGE_SIZE;
00114 }
00115
00116 vfree(mem);
00117 }
00118
00119
00129 int stk11xx_allocate_buffers(struct usb_stk11xx *dev)
00130 {
00131 int i;
00132 void *kbuf;
00133
00134 STK_DEBUG("Allocate video buffers\n");
00135
00136 if (dev == NULL)
00137 return -ENXIO;
00138
00139
00140 for (i=0; i<MAX_ISO_BUFS; i++) {
00141 if (dev->isobuf[i].data == NULL) {
00142 kbuf = kzalloc(ISO_BUFFER_SIZE, GFP_KERNEL);
00143
00144 if (kbuf == NULL) {
00145 STK_ERROR("Failed to allocate iso buffer %d\n", i);
00146 return -ENOMEM;
00147 }
00148
00149 STK_DEBUG("Allocated iso buffer at %p\n", kbuf);
00150
00151 dev->isobuf[i].data = kbuf;
00152 }
00153 }
00154
00155
00156 if (dev->framebuf == NULL) {
00157 kbuf = kzalloc(default_nbrframebuf * sizeof(struct stk11xx_frame_buf), GFP_KERNEL);
00158
00159 if (kbuf == NULL) {
00160 STK_ERROR("Failed to allocate frame buffer structure\n");
00161 return -ENOMEM;
00162 }
00163
00164 STK_DEBUG("Allocated frame buffer structure at %p\n", kbuf);
00165
00166 dev->framebuf = kbuf;
00167 }
00168
00169
00170 for (i=0; i<default_nbrframebuf; i++) {
00171 if (dev->framebuf[i].data == NULL) {
00172 kbuf = vmalloc(STK11XX_FRAME_SIZE);
00173
00174 if (kbuf == NULL) {
00175 STK_ERROR("Failed to allocate frame buffer %d\n", i);
00176 return -ENOMEM;
00177 }
00178
00179 STK_DEBUG("Allocated frame buffer %d at %p.\n", i, kbuf);
00180
00181 dev->framebuf[i].data = kbuf;
00182 memset(kbuf, 0, STK11XX_FRAME_SIZE);
00183 }
00184 }
00185
00186
00187 kbuf = stk11xx_rvmalloc(dev->nbuffers * dev->len_per_image);
00188
00189 if (kbuf == NULL) {
00190 STK_ERROR("Failed to allocate image buffer(s). needed (%d)\n",
00191 dev->nbuffers * dev->len_per_image);
00192 return -ENOMEM;
00193 }
00194
00195 STK_DEBUG("Allocated image buffer at %p\n", kbuf);
00196
00197 dev->image_data = kbuf;
00198
00199 for (i = 0; i < dev->nbuffers; i++) {
00200 dev->images[i].offset = i * dev->len_per_image;
00201 dev->images[i].vma_use_count = 0;
00202 }
00203
00204 for (; i < STK11XX_MAX_IMAGES; i++)
00205 dev->images[i].offset = 0;
00206
00207 kbuf = NULL;
00208
00209 return 0;
00210 }
00211
00212
00222 int stk11xx_reset_buffers(struct usb_stk11xx *dev)
00223 {
00224 int i;
00225 unsigned long flags;
00226
00227 STK_DEBUG("Reset all buffers\n");
00228
00229 spin_lock_irqsave(&dev->spinlock, flags);
00230
00231 dev->full_frames = NULL;
00232 dev->full_frames_tail = NULL;
00233
00234 for (i=0; i<dev->nbuffers; i++) {
00235 dev->framebuf[i].filled = 0;
00236 dev->framebuf[i].errors = 0;
00237
00238 if (i > 0)
00239 dev->framebuf[i].next = &dev->framebuf[i - 1];
00240 else
00241 dev->framebuf->next = NULL;
00242 }
00243
00244 dev->empty_frames = &dev->framebuf[dev->nbuffers - 1];
00245 dev->empty_frames_tail = dev->framebuf;
00246 dev->read_frame = NULL;
00247 dev->fill_frame = dev->empty_frames;
00248 dev->empty_frames = dev->empty_frames->next;
00249
00250 dev->image_read_pos = 0;
00251 dev->fill_image = 0;
00252
00253 spin_unlock_irqrestore(&dev->spinlock, flags);
00254
00255 for (i=0; i<dev->nbuffers; i++)
00256 dev->image_used[i] = 0;
00257
00258 return 0;
00259 }
00260
00261
00271 int stk11xx_clear_buffers(struct usb_stk11xx *dev)
00272 {
00273 memset(dev->image_data, 0x00, dev->nbuffers * dev->len_per_image);
00274
00275 return 0;
00276 }
00277
00278
00288 int stk11xx_free_buffers(struct usb_stk11xx *dev)
00289 {
00290 int i;
00291
00292 STK_DEBUG("Free buffers\n");
00293
00294 if (dev == NULL)
00295 return -1;
00296
00297
00298 for (i=0; i<MAX_ISO_BUFS; i++) {
00299 if (dev->isobuf[i].data != NULL) {
00300 kfree(dev->isobuf[i].data);
00301 dev->isobuf[i].data = NULL;
00302 }
00303 }
00304
00305
00306 if (dev->framebuf != NULL) {
00307 for (i=0; i<default_nbrframebuf; i++) {
00308 if (dev->framebuf[i].data != NULL) {
00309 vfree(dev->framebuf[i].data);
00310 dev->framebuf[i].data = NULL;
00311 }
00312 }
00313
00314 kfree(dev->framebuf);
00315 dev->framebuf = NULL;
00316 }
00317
00318
00319 if (dev->image_data != NULL)
00320 stk11xx_rvfree(dev->image_data, dev->nbuffers * dev->len_per_image);
00321
00322 dev->image_data = NULL;
00323
00324 return 0;
00325 }
00326
00327
00335 void stk11xx_next_image(struct usb_stk11xx *dev)
00336 {
00337 STK_STREAM("Select next image\n");
00338
00339 dev->image_used[dev->fill_image] = 0;
00340 dev->fill_image = (dev->fill_image + 1) % dev->nbuffers;
00341 }
00342
00343
00353 int stk11xx_next_frame(struct usb_stk11xx *dev)
00354 {
00355 int ret = 0;
00356 unsigned long flags;
00357
00358 STK_STREAM("Select next frame\n");
00359
00360 spin_lock_irqsave(&dev->spinlock, flags);
00361
00362 if (dev->fill_frame != NULL) {
00363 if (dev->full_frames == NULL) {
00364 dev->full_frames = dev->fill_frame;
00365 dev->full_frames_tail = dev->full_frames;
00366 }
00367 else {
00368 dev->full_frames_tail->next = dev->fill_frame;
00369 dev->full_frames_tail = dev->fill_frame;
00370 }
00371 }
00372
00373 if (dev->empty_frames != NULL) {
00374 dev->fill_frame = dev->empty_frames;
00375 dev->empty_frames = dev->empty_frames->next;
00376 }
00377 else {
00378 if (dev->full_frames == NULL) {
00379 STK_ERROR("Neither empty or full frames available!\n");
00380 spin_unlock_irqrestore(&dev->spinlock, flags);
00381 return -EINVAL;
00382 }
00383
00384 dev->fill_frame = dev->full_frames;
00385 dev->full_frames = dev->full_frames->next;
00386
00387 ret = 1;
00388 }
00389
00390 dev->fill_frame->next = NULL;
00391
00392 spin_unlock_irqrestore(&dev->spinlock, flags);
00393
00394 return ret;
00395 }
00396
00397
00408 int stk11xx_handle_frame(struct usb_stk11xx *dev)
00409 {
00410 int ret = 0;
00411 unsigned long flags;
00412
00413 STK_STREAM("Sync Handle Frame\n");
00414
00415 spin_lock_irqsave(&dev->spinlock, flags);
00416
00417 if (dev->read_frame != NULL) {
00418 spin_unlock_irqrestore(&dev->spinlock, flags);
00419 return ret;
00420 }
00421
00422 if (dev->full_frames == NULL) {
00423 }
00424 else {
00425 dev->read_frame = dev->full_frames;
00426 dev->full_frames = dev->full_frames->next;
00427 dev->read_frame->next = NULL;
00428 }
00429
00430 if (dev->read_frame != NULL) {
00431 spin_unlock_irqrestore(&dev->spinlock, flags);
00432 ret = stk11xx_decompress(dev);
00433 spin_lock_irqsave(&dev->spinlock, flags);
00434
00435 if (dev->empty_frames == NULL) {
00436 dev->empty_frames = dev->read_frame;
00437 dev->empty_frames_tail = dev->empty_frames;
00438 }
00439 else {
00440 dev->empty_frames_tail->next = dev->read_frame;
00441 dev->empty_frames_tail = dev->read_frame;
00442 }
00443
00444 dev->read_frame = NULL;
00445 }
00446
00447 spin_unlock_irqrestore(&dev->spinlock, flags);
00448
00449 dev_stk11xx_watchdog_camera(dev);
00450
00451 return ret;
00452 }
00453