Commit | Line | Data |
---|---|---|
68e342b3 DC |
1 | /* |
2 | * ispstat.c | |
3 | * | |
4 | * TI OMAP3 ISP - Statistics core | |
5 | * | |
6 | * Copyright (C) 2010 Nokia Corporation | |
7 | * Copyright (C) 2009 Texas Instruments, Inc | |
8 | * | |
9 | * Contacts: David Cohen <dacohen@gmail.com> | |
10 | * Laurent Pinchart <laurent.pinchart@ideasonboard.com> | |
11 | * Sakari Ailus <sakari.ailus@iki.fi> | |
12 | * | |
13 | * This program is free software; you can redistribute it and/or modify | |
14 | * it under the terms of the GNU General Public License version 2 as | |
15 | * published by the Free Software Foundation. | |
16 | * | |
17 | * This program is distributed in the hope that it will be useful, but | |
18 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
20 | * General Public License for more details. | |
21 | * | |
22 | * You should have received a copy of the GNU General Public License | |
23 | * along with this program; if not, write to the Free Software | |
24 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA | |
25 | * 02110-1301 USA | |
26 | */ | |
27 | ||
28 | #include <linux/dma-mapping.h> | |
29 | #include <linux/slab.h> | |
30 | #include <linux/uaccess.h> | |
31 | ||
32 | #include "isp.h" | |
33 | ||
34 | #define IS_COHERENT_BUF(stat) ((stat)->dma_ch >= 0) | |
35 | ||
36 | /* | |
37 | * MAGIC_SIZE must always be the greatest common divisor of | |
38 | * AEWB_PACKET_SIZE and AF_PAXEL_SIZE. | |
39 | */ | |
40 | #define MAGIC_SIZE 16 | |
41 | #define MAGIC_NUM 0x55 | |
42 | ||
43 | /* HACK: AF module seems to be writing one more paxel data than it should. */ | |
44 | #define AF_EXTRA_DATA OMAP3ISP_AF_PAXEL_SIZE | |
45 | ||
46 | /* | |
47 | * HACK: H3A modules go to an invalid state after have a SBL overflow. It makes | |
48 | * the next buffer to start to be written in the same point where the overflow | |
49 | * occurred instead of the configured address. The only known way to make it to | |
50 | * go back to a valid state is having a valid buffer processing. Of course it | |
51 | * requires at least a doubled buffer size to avoid an access to invalid memory | |
52 | * region. But it does not fix everything. It may happen more than one | |
53 | * consecutive SBL overflows. In that case, it might be unpredictable how many | |
54 | * buffers the allocated memory should fit. For that case, a recover | |
55 | * configuration was created. It produces the minimum buffer size for each H3A | |
56 | * module and decrease the change for more SBL overflows. This recover state | |
57 | * will be enabled every time a SBL overflow occur. As the output buffer size | |
58 | * isn't big, it's possible to have an extra size able to fit many recover | |
59 | * buffers making it extreamily unlikely to have an access to invalid memory | |
60 | * region. | |
61 | */ | |
62 | #define NUM_H3A_RECOVER_BUFS 10 | |
63 | ||
64 | /* | |
65 | * HACK: Because of HW issues the generic layer sometimes need to have | |
66 | * different behaviour for different statistic modules. | |
67 | */ | |
68 | #define IS_H3A_AF(stat) ((stat) == &(stat)->isp->isp_af) | |
69 | #define IS_H3A_AEWB(stat) ((stat) == &(stat)->isp->isp_aewb) | |
70 | #define IS_H3A(stat) (IS_H3A_AF(stat) || IS_H3A_AEWB(stat)) | |
71 | ||
72 | static void __isp_stat_buf_sync_magic(struct ispstat *stat, | |
73 | struct ispstat_buffer *buf, | |
74 | u32 buf_size, enum dma_data_direction dir, | |
75 | void (*dma_sync)(struct device *, | |
76 | dma_addr_t, unsigned long, size_t, | |
77 | enum dma_data_direction)) | |
78 | { | |
79 | struct device *dev = stat->isp->dev; | |
80 | struct page *pg; | |
81 | dma_addr_t dma_addr; | |
82 | u32 offset; | |
83 | ||
84 | /* Initial magic words */ | |
85 | pg = vmalloc_to_page(buf->virt_addr); | |
86 | dma_addr = pfn_to_dma(dev, page_to_pfn(pg)); | |
87 | dma_sync(dev, dma_addr, 0, MAGIC_SIZE, dir); | |
88 | ||
89 | /* Final magic words */ | |
90 | pg = vmalloc_to_page(buf->virt_addr + buf_size); | |
91 | dma_addr = pfn_to_dma(dev, page_to_pfn(pg)); | |
92 | offset = ((u32)buf->virt_addr + buf_size) & ~PAGE_MASK; | |
93 | dma_sync(dev, dma_addr, offset, MAGIC_SIZE, dir); | |
94 | } | |
95 | ||
96 | static void isp_stat_buf_sync_magic_for_device(struct ispstat *stat, | |
97 | struct ispstat_buffer *buf, | |
98 | u32 buf_size, | |
99 | enum dma_data_direction dir) | |
100 | { | |
101 | if (IS_COHERENT_BUF(stat)) | |
102 | return; | |
103 | ||
104 | __isp_stat_buf_sync_magic(stat, buf, buf_size, dir, | |
105 | dma_sync_single_range_for_device); | |
106 | } | |
107 | ||
108 | static void isp_stat_buf_sync_magic_for_cpu(struct ispstat *stat, | |
109 | struct ispstat_buffer *buf, | |
110 | u32 buf_size, | |
111 | enum dma_data_direction dir) | |
112 | { | |
113 | if (IS_COHERENT_BUF(stat)) | |
114 | return; | |
115 | ||
116 | __isp_stat_buf_sync_magic(stat, buf, buf_size, dir, | |
117 | dma_sync_single_range_for_cpu); | |
118 | } | |
119 | ||
120 | static int isp_stat_buf_check_magic(struct ispstat *stat, | |
121 | struct ispstat_buffer *buf) | |
122 | { | |
123 | const u32 buf_size = IS_H3A_AF(stat) ? | |
124 | buf->buf_size + AF_EXTRA_DATA : buf->buf_size; | |
125 | u8 *w; | |
126 | u8 *end; | |
127 | int ret = -EINVAL; | |
128 | ||
129 | isp_stat_buf_sync_magic_for_cpu(stat, buf, buf_size, DMA_FROM_DEVICE); | |
130 | ||
131 | /* Checking initial magic numbers. They shouldn't be here anymore. */ | |
132 | for (w = buf->virt_addr, end = w + MAGIC_SIZE; w < end; w++) | |
133 | if (likely(*w != MAGIC_NUM)) | |
134 | ret = 0; | |
135 | ||
136 | if (ret) { | |
137 | dev_dbg(stat->isp->dev, "%s: beginning magic check does not " | |
138 | "match.\n", stat->subdev.name); | |
139 | return ret; | |
140 | } | |
141 | ||
142 | /* Checking magic numbers at the end. They must be still here. */ | |
143 | for (w = buf->virt_addr + buf_size, end = w + MAGIC_SIZE; | |
144 | w < end; w++) { | |
145 | if (unlikely(*w != MAGIC_NUM)) { | |
146 | dev_dbg(stat->isp->dev, "%s: endding magic check does " | |
147 | "not match.\n", stat->subdev.name); | |
148 | return -EINVAL; | |
149 | } | |
150 | } | |
151 | ||
152 | isp_stat_buf_sync_magic_for_device(stat, buf, buf_size, | |
153 | DMA_FROM_DEVICE); | |
154 | ||
155 | return 0; | |
156 | } | |
157 | ||
158 | static void isp_stat_buf_insert_magic(struct ispstat *stat, | |
159 | struct ispstat_buffer *buf) | |
160 | { | |
161 | const u32 buf_size = IS_H3A_AF(stat) ? | |
162 | stat->buf_size + AF_EXTRA_DATA : stat->buf_size; | |
163 | ||
164 | isp_stat_buf_sync_magic_for_cpu(stat, buf, buf_size, DMA_FROM_DEVICE); | |
165 | ||
166 | /* | |
167 | * Inserting MAGIC_NUM at the beginning and end of the buffer. | |
168 | * buf->buf_size is set only after the buffer is queued. For now the | |
169 | * right buf_size for the current configuration is pointed by | |
170 | * stat->buf_size. | |
171 | */ | |
172 | memset(buf->virt_addr, MAGIC_NUM, MAGIC_SIZE); | |
173 | memset(buf->virt_addr + buf_size, MAGIC_NUM, MAGIC_SIZE); | |
174 | ||
175 | isp_stat_buf_sync_magic_for_device(stat, buf, buf_size, | |
176 | DMA_BIDIRECTIONAL); | |
177 | } | |
178 | ||
179 | static void isp_stat_buf_sync_for_device(struct ispstat *stat, | |
180 | struct ispstat_buffer *buf) | |
181 | { | |
182 | if (IS_COHERENT_BUF(stat)) | |
183 | return; | |
184 | ||
185 | dma_sync_sg_for_device(stat->isp->dev, buf->iovm->sgt->sgl, | |
186 | buf->iovm->sgt->nents, DMA_FROM_DEVICE); | |
187 | } | |
188 | ||
189 | static void isp_stat_buf_sync_for_cpu(struct ispstat *stat, | |
190 | struct ispstat_buffer *buf) | |
191 | { | |
192 | if (IS_COHERENT_BUF(stat)) | |
193 | return; | |
194 | ||
195 | dma_sync_sg_for_cpu(stat->isp->dev, buf->iovm->sgt->sgl, | |
196 | buf->iovm->sgt->nents, DMA_FROM_DEVICE); | |
197 | } | |
198 | ||
199 | static void isp_stat_buf_clear(struct ispstat *stat) | |
200 | { | |
201 | int i; | |
202 | ||
203 | for (i = 0; i < STAT_MAX_BUFS; i++) | |
204 | stat->buf[i].empty = 1; | |
205 | } | |
206 | ||
207 | static struct ispstat_buffer * | |
208 | __isp_stat_buf_find(struct ispstat *stat, int look_empty) | |
209 | { | |
210 | struct ispstat_buffer *found = NULL; | |
211 | int i; | |
212 | ||
213 | for (i = 0; i < STAT_MAX_BUFS; i++) { | |
214 | struct ispstat_buffer *curr = &stat->buf[i]; | |
215 | ||
216 | /* | |
217 | * Don't select the buffer which is being copied to | |
218 | * userspace or used by the module. | |
219 | */ | |
220 | if (curr == stat->locked_buf || curr == stat->active_buf) | |
221 | continue; | |
222 | ||
223 | /* Don't select uninitialised buffers if it's not required */ | |
224 | if (!look_empty && curr->empty) | |
225 | continue; | |
226 | ||
227 | /* Pick uninitialised buffer over anything else if look_empty */ | |
228 | if (curr->empty) { | |
229 | found = curr; | |
230 | break; | |
231 | } | |
232 | ||
233 | /* Choose the oldest buffer */ | |
234 | if (!found || | |
235 | (s32)curr->frame_number - (s32)found->frame_number < 0) | |
236 | found = curr; | |
237 | } | |
238 | ||
239 | return found; | |
240 | } | |
241 | ||
242 | static inline struct ispstat_buffer * | |
243 | isp_stat_buf_find_oldest(struct ispstat *stat) | |
244 | { | |
245 | return __isp_stat_buf_find(stat, 0); | |
246 | } | |
247 | ||
248 | static inline struct ispstat_buffer * | |
249 | isp_stat_buf_find_oldest_or_empty(struct ispstat *stat) | |
250 | { | |
251 | return __isp_stat_buf_find(stat, 1); | |
252 | } | |
253 | ||
254 | static int isp_stat_buf_queue(struct ispstat *stat) | |
255 | { | |
256 | if (!stat->active_buf) | |
257 | return STAT_NO_BUF; | |
258 | ||
259 | do_gettimeofday(&stat->active_buf->ts); | |
260 | ||
261 | stat->active_buf->buf_size = stat->buf_size; | |
262 | if (isp_stat_buf_check_magic(stat, stat->active_buf)) { | |
263 | dev_dbg(stat->isp->dev, "%s: data wasn't properly written.\n", | |
264 | stat->subdev.name); | |
265 | return STAT_NO_BUF; | |
266 | } | |
267 | stat->active_buf->config_counter = stat->config_counter; | |
268 | stat->active_buf->frame_number = stat->frame_number; | |
269 | stat->active_buf->empty = 0; | |
270 | stat->active_buf = NULL; | |
271 | ||
272 | return STAT_BUF_DONE; | |
273 | } | |
274 | ||
275 | /* Get next free buffer to write the statistics to and mark it active. */ | |
276 | static void isp_stat_buf_next(struct ispstat *stat) | |
277 | { | |
278 | if (unlikely(stat->active_buf)) | |
279 | /* Overwriting unused active buffer */ | |
280 | dev_dbg(stat->isp->dev, "%s: new buffer requested without " | |
281 | "queuing active one.\n", | |
282 | stat->subdev.name); | |
283 | else | |
284 | stat->active_buf = isp_stat_buf_find_oldest_or_empty(stat); | |
285 | } | |
286 | ||
287 | static void isp_stat_buf_release(struct ispstat *stat) | |
288 | { | |
289 | unsigned long flags; | |
290 | ||
291 | isp_stat_buf_sync_for_device(stat, stat->locked_buf); | |
292 | spin_lock_irqsave(&stat->isp->stat_lock, flags); | |
293 | stat->locked_buf = NULL; | |
294 | spin_unlock_irqrestore(&stat->isp->stat_lock, flags); | |
295 | } | |
296 | ||
297 | /* Get buffer to userspace. */ | |
298 | static struct ispstat_buffer *isp_stat_buf_get(struct ispstat *stat, | |
299 | struct omap3isp_stat_data *data) | |
300 | { | |
301 | int rval = 0; | |
302 | unsigned long flags; | |
303 | struct ispstat_buffer *buf; | |
304 | ||
305 | spin_lock_irqsave(&stat->isp->stat_lock, flags); | |
306 | ||
307 | while (1) { | |
308 | buf = isp_stat_buf_find_oldest(stat); | |
309 | if (!buf) { | |
310 | spin_unlock_irqrestore(&stat->isp->stat_lock, flags); | |
311 | dev_dbg(stat->isp->dev, "%s: cannot find a buffer.\n", | |
312 | stat->subdev.name); | |
313 | return ERR_PTR(-EBUSY); | |
314 | } | |
315 | if (isp_stat_buf_check_magic(stat, buf)) { | |
316 | dev_dbg(stat->isp->dev, "%s: current buffer has " | |
317 | "corrupted data\n.", stat->subdev.name); | |
318 | /* Mark empty because it doesn't have valid data. */ | |
319 | buf->empty = 1; | |
320 | } else { | |
321 | /* Buffer isn't corrupted. */ | |
322 | break; | |
323 | } | |
324 | } | |
325 | ||
326 | stat->locked_buf = buf; | |
327 | ||
328 | spin_unlock_irqrestore(&stat->isp->stat_lock, flags); | |
329 | ||
330 | if (buf->buf_size > data->buf_size) { | |
331 | dev_warn(stat->isp->dev, "%s: userspace's buffer size is " | |
332 | "not enough.\n", stat->subdev.name); | |
333 | isp_stat_buf_release(stat); | |
334 | return ERR_PTR(-EINVAL); | |
335 | } | |
336 | ||
337 | isp_stat_buf_sync_for_cpu(stat, buf); | |
338 | ||
339 | rval = copy_to_user(data->buf, | |
340 | buf->virt_addr, | |
341 | buf->buf_size); | |
342 | ||
343 | if (rval) { | |
344 | dev_info(stat->isp->dev, | |
345 | "%s: failed copying %d bytes of stat data\n", | |
346 | stat->subdev.name, rval); | |
347 | buf = ERR_PTR(-EFAULT); | |
348 | isp_stat_buf_release(stat); | |
349 | } | |
350 | ||
351 | return buf; | |
352 | } | |
353 | ||
354 | static void isp_stat_bufs_free(struct ispstat *stat) | |
355 | { | |
356 | struct isp_device *isp = stat->isp; | |
357 | int i; | |
358 | ||
359 | for (i = 0; i < STAT_MAX_BUFS; i++) { | |
360 | struct ispstat_buffer *buf = &stat->buf[i]; | |
361 | ||
362 | if (!IS_COHERENT_BUF(stat)) { | |
363 | if (IS_ERR_OR_NULL((void *)buf->iommu_addr)) | |
364 | continue; | |
365 | if (buf->iovm) | |
366 | dma_unmap_sg(isp->dev, buf->iovm->sgt->sgl, | |
367 | buf->iovm->sgt->nents, | |
368 | DMA_FROM_DEVICE); | |
6c32df43 OBC |
369 | omap_iommu_vfree(isp->domain, isp->iommu, |
370 | buf->iommu_addr); | |
68e342b3 DC |
371 | } else { |
372 | if (!buf->virt_addr) | |
373 | continue; | |
374 | dma_free_coherent(stat->isp->dev, stat->buf_alloc_size, | |
375 | buf->virt_addr, buf->dma_addr); | |
376 | } | |
377 | buf->iommu_addr = 0; | |
378 | buf->iovm = NULL; | |
379 | buf->dma_addr = 0; | |
380 | buf->virt_addr = NULL; | |
381 | buf->empty = 1; | |
382 | } | |
383 | ||
384 | dev_dbg(stat->isp->dev, "%s: all buffers were freed.\n", | |
385 | stat->subdev.name); | |
386 | ||
387 | stat->buf_alloc_size = 0; | |
388 | stat->active_buf = NULL; | |
389 | } | |
390 | ||
391 | static int isp_stat_bufs_alloc_iommu(struct ispstat *stat, unsigned int size) | |
392 | { | |
393 | struct isp_device *isp = stat->isp; | |
394 | int i; | |
395 | ||
396 | stat->buf_alloc_size = size; | |
397 | ||
398 | for (i = 0; i < STAT_MAX_BUFS; i++) { | |
399 | struct ispstat_buffer *buf = &stat->buf[i]; | |
400 | struct iovm_struct *iovm; | |
401 | ||
402 | WARN_ON(buf->dma_addr); | |
6c32df43 | 403 | buf->iommu_addr = omap_iommu_vmalloc(isp->domain, isp->iommu, 0, |
f626b52d | 404 | size, IOMMU_FLAG); |
68e342b3 DC |
405 | if (IS_ERR((void *)buf->iommu_addr)) { |
406 | dev_err(stat->isp->dev, | |
407 | "%s: Can't acquire memory for " | |
408 | "buffer %d\n", stat->subdev.name, i); | |
409 | isp_stat_bufs_free(stat); | |
410 | return -ENOMEM; | |
411 | } | |
412 | ||
6c32df43 | 413 | iovm = omap_find_iovm_area(isp->iommu, buf->iommu_addr); |
68e342b3 DC |
414 | if (!iovm || |
415 | !dma_map_sg(isp->dev, iovm->sgt->sgl, iovm->sgt->nents, | |
416 | DMA_FROM_DEVICE)) { | |
417 | isp_stat_bufs_free(stat); | |
418 | return -ENOMEM; | |
419 | } | |
420 | buf->iovm = iovm; | |
421 | ||
6c32df43 | 422 | buf->virt_addr = omap_da_to_va(stat->isp->iommu, |
68e342b3 DC |
423 | (u32)buf->iommu_addr); |
424 | buf->empty = 1; | |
425 | dev_dbg(stat->isp->dev, "%s: buffer[%d] allocated." | |
426 | "iommu_addr=0x%08lx virt_addr=0x%08lx", | |
427 | stat->subdev.name, i, buf->iommu_addr, | |
428 | (unsigned long)buf->virt_addr); | |
429 | } | |
430 | ||
431 | return 0; | |
432 | } | |
433 | ||
434 | static int isp_stat_bufs_alloc_dma(struct ispstat *stat, unsigned int size) | |
435 | { | |
436 | int i; | |
437 | ||
438 | stat->buf_alloc_size = size; | |
439 | ||
440 | for (i = 0; i < STAT_MAX_BUFS; i++) { | |
441 | struct ispstat_buffer *buf = &stat->buf[i]; | |
442 | ||
443 | WARN_ON(buf->iommu_addr); | |
444 | buf->virt_addr = dma_alloc_coherent(stat->isp->dev, size, | |
445 | &buf->dma_addr, GFP_KERNEL | GFP_DMA); | |
446 | ||
447 | if (!buf->virt_addr || !buf->dma_addr) { | |
448 | dev_info(stat->isp->dev, | |
449 | "%s: Can't acquire memory for " | |
450 | "DMA buffer %d\n", stat->subdev.name, i); | |
451 | isp_stat_bufs_free(stat); | |
452 | return -ENOMEM; | |
453 | } | |
454 | buf->empty = 1; | |
455 | ||
456 | dev_dbg(stat->isp->dev, "%s: buffer[%d] allocated." | |
457 | "dma_addr=0x%08lx virt_addr=0x%08lx\n", | |
458 | stat->subdev.name, i, (unsigned long)buf->dma_addr, | |
459 | (unsigned long)buf->virt_addr); | |
460 | } | |
461 | ||
462 | return 0; | |
463 | } | |
464 | ||
465 | static int isp_stat_bufs_alloc(struct ispstat *stat, u32 size) | |
466 | { | |
467 | unsigned long flags; | |
468 | ||
469 | spin_lock_irqsave(&stat->isp->stat_lock, flags); | |
470 | ||
471 | BUG_ON(stat->locked_buf != NULL); | |
472 | ||
473 | /* Are the old buffers big enough? */ | |
474 | if (stat->buf_alloc_size >= size) { | |
475 | spin_unlock_irqrestore(&stat->isp->stat_lock, flags); | |
476 | return 0; | |
477 | } | |
478 | ||
479 | if (stat->state != ISPSTAT_DISABLED || stat->buf_processing) { | |
480 | dev_info(stat->isp->dev, | |
481 | "%s: trying to allocate memory when busy\n", | |
482 | stat->subdev.name); | |
483 | spin_unlock_irqrestore(&stat->isp->stat_lock, flags); | |
484 | return -EBUSY; | |
485 | } | |
486 | ||
487 | spin_unlock_irqrestore(&stat->isp->stat_lock, flags); | |
488 | ||
489 | isp_stat_bufs_free(stat); | |
490 | ||
491 | if (IS_COHERENT_BUF(stat)) | |
492 | return isp_stat_bufs_alloc_dma(stat, size); | |
493 | else | |
494 | return isp_stat_bufs_alloc_iommu(stat, size); | |
495 | } | |
496 | ||
497 | static void isp_stat_queue_event(struct ispstat *stat, int err) | |
498 | { | |
499 | struct video_device *vdev = &stat->subdev.devnode; | |
500 | struct v4l2_event event; | |
501 | struct omap3isp_stat_event_status *status = (void *)event.u.data; | |
502 | ||
503 | memset(&event, 0, sizeof(event)); | |
504 | if (!err) { | |
505 | status->frame_number = stat->frame_number; | |
506 | status->config_counter = stat->config_counter; | |
507 | } else { | |
508 | status->buf_err = 1; | |
509 | } | |
510 | event.type = stat->event_type; | |
511 | v4l2_event_queue(vdev, &event); | |
512 | } | |
513 | ||
514 | ||
515 | /* | |
516 | * omap3isp_stat_request_statistics - Request statistics. | |
517 | * @data: Pointer to return statistics data. | |
518 | * | |
519 | * Returns 0 if successful. | |
520 | */ | |
521 | int omap3isp_stat_request_statistics(struct ispstat *stat, | |
522 | struct omap3isp_stat_data *data) | |
523 | { | |
524 | struct ispstat_buffer *buf; | |
525 | ||
526 | if (stat->state != ISPSTAT_ENABLED) { | |
527 | dev_dbg(stat->isp->dev, "%s: engine not enabled.\n", | |
528 | stat->subdev.name); | |
529 | return -EINVAL; | |
530 | } | |
531 | ||
532 | mutex_lock(&stat->ioctl_lock); | |
533 | buf = isp_stat_buf_get(stat, data); | |
534 | if (IS_ERR(buf)) { | |
535 | mutex_unlock(&stat->ioctl_lock); | |
536 | return PTR_ERR(buf); | |
537 | } | |
538 | ||
539 | data->ts = buf->ts; | |
540 | data->config_counter = buf->config_counter; | |
541 | data->frame_number = buf->frame_number; | |
542 | data->buf_size = buf->buf_size; | |
543 | ||
544 | buf->empty = 1; | |
545 | isp_stat_buf_release(stat); | |
546 | mutex_unlock(&stat->ioctl_lock); | |
547 | ||
548 | return 0; | |
549 | } | |
550 | ||
551 | /* | |
552 | * omap3isp_stat_config - Receives new statistic engine configuration. | |
553 | * @new_conf: Pointer to config structure. | |
554 | * | |
555 | * Returns 0 if successful, -EINVAL if new_conf pointer is NULL, -ENOMEM if | |
556 | * was unable to allocate memory for the buffer, or other errors if parameters | |
557 | * are invalid. | |
558 | */ | |
559 | int omap3isp_stat_config(struct ispstat *stat, void *new_conf) | |
560 | { | |
561 | int ret; | |
562 | unsigned long irqflags; | |
563 | struct ispstat_generic_config *user_cfg = new_conf; | |
564 | u32 buf_size = user_cfg->buf_size; | |
565 | ||
566 | if (!new_conf) { | |
567 | dev_dbg(stat->isp->dev, "%s: configuration is NULL\n", | |
568 | stat->subdev.name); | |
569 | return -EINVAL; | |
570 | } | |
571 | ||
572 | mutex_lock(&stat->ioctl_lock); | |
573 | ||
574 | dev_dbg(stat->isp->dev, "%s: configuring module with buffer " | |
575 | "size=0x%08lx\n", stat->subdev.name, (unsigned long)buf_size); | |
576 | ||
577 | ret = stat->ops->validate_params(stat, new_conf); | |
578 | if (ret) { | |
579 | mutex_unlock(&stat->ioctl_lock); | |
580 | dev_dbg(stat->isp->dev, "%s: configuration values are " | |
581 | "invalid.\n", stat->subdev.name); | |
582 | return ret; | |
583 | } | |
584 | ||
585 | if (buf_size != user_cfg->buf_size) | |
586 | dev_dbg(stat->isp->dev, "%s: driver has corrected buffer size " | |
587 | "request to 0x%08lx\n", stat->subdev.name, | |
588 | (unsigned long)user_cfg->buf_size); | |
589 | ||
590 | /* | |
591 | * Hack: H3A modules may need a doubled buffer size to avoid access | |
592 | * to a invalid memory address after a SBL overflow. | |
593 | * The buffer size is always PAGE_ALIGNED. | |
594 | * Hack 2: MAGIC_SIZE is added to buf_size so a magic word can be | |
595 | * inserted at the end to data integrity check purpose. | |
596 | * Hack 3: AF module writes one paxel data more than it should, so | |
597 | * the buffer allocation must consider it to avoid invalid memory | |
598 | * access. | |
599 | * Hack 4: H3A need to allocate extra space for the recover state. | |
600 | */ | |
601 | if (IS_H3A(stat)) { | |
602 | buf_size = user_cfg->buf_size * 2 + MAGIC_SIZE; | |
603 | if (IS_H3A_AF(stat)) | |
604 | /* | |
605 | * Adding one extra paxel data size for each recover | |
606 | * buffer + 2 regular ones. | |
607 | */ | |
608 | buf_size += AF_EXTRA_DATA * (NUM_H3A_RECOVER_BUFS + 2); | |
609 | if (stat->recover_priv) { | |
610 | struct ispstat_generic_config *recover_cfg = | |
611 | stat->recover_priv; | |
612 | buf_size += recover_cfg->buf_size * | |
613 | NUM_H3A_RECOVER_BUFS; | |
614 | } | |
615 | buf_size = PAGE_ALIGN(buf_size); | |
616 | } else { /* Histogram */ | |
617 | buf_size = PAGE_ALIGN(user_cfg->buf_size + MAGIC_SIZE); | |
618 | } | |
619 | ||
620 | ret = isp_stat_bufs_alloc(stat, buf_size); | |
621 | if (ret) { | |
622 | mutex_unlock(&stat->ioctl_lock); | |
623 | return ret; | |
624 | } | |
625 | ||
626 | spin_lock_irqsave(&stat->isp->stat_lock, irqflags); | |
627 | stat->ops->set_params(stat, new_conf); | |
628 | spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); | |
629 | ||
630 | /* | |
631 | * Returning the right future config_counter for this setup, so | |
632 | * userspace can *know* when it has been applied. | |
633 | */ | |
634 | user_cfg->config_counter = stat->config_counter + stat->inc_config; | |
635 | ||
636 | /* Module has a valid configuration. */ | |
637 | stat->configured = 1; | |
638 | dev_dbg(stat->isp->dev, "%s: module has been successfully " | |
639 | "configured.\n", stat->subdev.name); | |
640 | ||
641 | mutex_unlock(&stat->ioctl_lock); | |
642 | ||
643 | return 0; | |
644 | } | |
645 | ||
646 | /* | |
647 | * isp_stat_buf_process - Process statistic buffers. | |
648 | * @buf_state: points out if buffer is ready to be processed. It's necessary | |
649 | * because histogram needs to copy the data from internal memory | |
650 | * before be able to process the buffer. | |
651 | */ | |
652 | static int isp_stat_buf_process(struct ispstat *stat, int buf_state) | |
653 | { | |
654 | int ret = STAT_NO_BUF; | |
655 | ||
656 | if (!atomic_add_unless(&stat->buf_err, -1, 0) && | |
657 | buf_state == STAT_BUF_DONE && stat->state == ISPSTAT_ENABLED) { | |
658 | ret = isp_stat_buf_queue(stat); | |
659 | isp_stat_buf_next(stat); | |
660 | } | |
661 | ||
662 | return ret; | |
663 | } | |
664 | ||
665 | int omap3isp_stat_pcr_busy(struct ispstat *stat) | |
666 | { | |
667 | return stat->ops->busy(stat); | |
668 | } | |
669 | ||
670 | int omap3isp_stat_busy(struct ispstat *stat) | |
671 | { | |
672 | return omap3isp_stat_pcr_busy(stat) | stat->buf_processing | | |
673 | (stat->state != ISPSTAT_DISABLED); | |
674 | } | |
675 | ||
676 | /* | |
677 | * isp_stat_pcr_enable - Disables/Enables statistic engines. | |
678 | * @pcr_enable: 0/1 - Disables/Enables the engine. | |
679 | * | |
680 | * Must be called from ISP driver when the module is idle and synchronized | |
681 | * with CCDC. | |
682 | */ | |
683 | static void isp_stat_pcr_enable(struct ispstat *stat, u8 pcr_enable) | |
684 | { | |
685 | if ((stat->state != ISPSTAT_ENABLING && | |
686 | stat->state != ISPSTAT_ENABLED) && pcr_enable) | |
687 | /* Userspace has disabled the module. Aborting. */ | |
688 | return; | |
689 | ||
690 | stat->ops->enable(stat, pcr_enable); | |
691 | if (stat->state == ISPSTAT_DISABLING && !pcr_enable) | |
692 | stat->state = ISPSTAT_DISABLED; | |
693 | else if (stat->state == ISPSTAT_ENABLING && pcr_enable) | |
694 | stat->state = ISPSTAT_ENABLED; | |
695 | } | |
696 | ||
697 | void omap3isp_stat_suspend(struct ispstat *stat) | |
698 | { | |
699 | unsigned long flags; | |
700 | ||
701 | spin_lock_irqsave(&stat->isp->stat_lock, flags); | |
702 | ||
703 | if (stat->state != ISPSTAT_DISABLED) | |
704 | stat->ops->enable(stat, 0); | |
705 | if (stat->state == ISPSTAT_ENABLED) | |
706 | stat->state = ISPSTAT_SUSPENDED; | |
707 | ||
708 | spin_unlock_irqrestore(&stat->isp->stat_lock, flags); | |
709 | } | |
710 | ||
711 | void omap3isp_stat_resume(struct ispstat *stat) | |
712 | { | |
713 | /* Module will be re-enabled with its pipeline */ | |
714 | if (stat->state == ISPSTAT_SUSPENDED) | |
715 | stat->state = ISPSTAT_ENABLING; | |
716 | } | |
717 | ||
718 | static void isp_stat_try_enable(struct ispstat *stat) | |
719 | { | |
720 | unsigned long irqflags; | |
721 | ||
722 | if (stat->priv == NULL) | |
723 | /* driver wasn't initialised */ | |
724 | return; | |
725 | ||
726 | spin_lock_irqsave(&stat->isp->stat_lock, irqflags); | |
727 | if (stat->state == ISPSTAT_ENABLING && !stat->buf_processing && | |
728 | stat->buf_alloc_size) { | |
729 | /* | |
730 | * Userspace's requested to enable the engine but it wasn't yet. | |
731 | * Let's do that now. | |
732 | */ | |
733 | stat->update = 1; | |
734 | isp_stat_buf_next(stat); | |
735 | stat->ops->setup_regs(stat, stat->priv); | |
736 | isp_stat_buf_insert_magic(stat, stat->active_buf); | |
737 | ||
738 | /* | |
739 | * H3A module has some hw issues which forces the driver to | |
740 | * ignore next buffers even if it was disabled in the meantime. | |
741 | * On the other hand, Histogram shouldn't ignore buffers anymore | |
742 | * if it's being enabled. | |
743 | */ | |
744 | if (!IS_H3A(stat)) | |
745 | atomic_set(&stat->buf_err, 0); | |
746 | ||
747 | isp_stat_pcr_enable(stat, 1); | |
748 | spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); | |
749 | dev_dbg(stat->isp->dev, "%s: module is enabled.\n", | |
750 | stat->subdev.name); | |
751 | } else { | |
752 | spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); | |
753 | } | |
754 | } | |
755 | ||
756 | void omap3isp_stat_isr_frame_sync(struct ispstat *stat) | |
757 | { | |
758 | isp_stat_try_enable(stat); | |
759 | } | |
760 | ||
761 | void omap3isp_stat_sbl_overflow(struct ispstat *stat) | |
762 | { | |
763 | unsigned long irqflags; | |
764 | ||
765 | spin_lock_irqsave(&stat->isp->stat_lock, irqflags); | |
766 | /* | |
767 | * Due to a H3A hw issue which prevents the next buffer to start from | |
768 | * the correct memory address, 2 buffers must be ignored. | |
769 | */ | |
770 | atomic_set(&stat->buf_err, 2); | |
771 | ||
772 | /* | |
773 | * If more than one SBL overflow happen in a row, H3A module may access | |
774 | * invalid memory region. | |
775 | * stat->sbl_ovl_recover is set to tell to the driver to temporarily use | |
776 | * a soft configuration which helps to avoid consecutive overflows. | |
777 | */ | |
778 | if (stat->recover_priv) | |
779 | stat->sbl_ovl_recover = 1; | |
780 | spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); | |
781 | } | |
782 | ||
783 | /* | |
784 | * omap3isp_stat_enable - Disable/Enable statistic engine as soon as possible | |
785 | * @enable: 0/1 - Disables/Enables the engine. | |
786 | * | |
787 | * Client should configure all the module registers before this. | |
788 | * This function can be called from a userspace request. | |
789 | */ | |
790 | int omap3isp_stat_enable(struct ispstat *stat, u8 enable) | |
791 | { | |
792 | unsigned long irqflags; | |
793 | ||
794 | dev_dbg(stat->isp->dev, "%s: user wants to %s module.\n", | |
795 | stat->subdev.name, enable ? "enable" : "disable"); | |
796 | ||
797 | /* Prevent enabling while configuring */ | |
798 | mutex_lock(&stat->ioctl_lock); | |
799 | ||
800 | spin_lock_irqsave(&stat->isp->stat_lock, irqflags); | |
801 | ||
802 | if (!stat->configured && enable) { | |
803 | spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); | |
804 | mutex_unlock(&stat->ioctl_lock); | |
805 | dev_dbg(stat->isp->dev, "%s: cannot enable module as it's " | |
806 | "never been successfully configured so far.\n", | |
807 | stat->subdev.name); | |
808 | return -EINVAL; | |
809 | } | |
810 | ||
811 | if (enable) { | |
812 | if (stat->state == ISPSTAT_DISABLING) | |
813 | /* Previous disabling request wasn't done yet */ | |
814 | stat->state = ISPSTAT_ENABLED; | |
815 | else if (stat->state == ISPSTAT_DISABLED) | |
816 | /* Module is now being enabled */ | |
817 | stat->state = ISPSTAT_ENABLING; | |
818 | } else { | |
819 | if (stat->state == ISPSTAT_ENABLING) { | |
820 | /* Previous enabling request wasn't done yet */ | |
821 | stat->state = ISPSTAT_DISABLED; | |
822 | } else if (stat->state == ISPSTAT_ENABLED) { | |
823 | /* Module is now being disabled */ | |
824 | stat->state = ISPSTAT_DISABLING; | |
825 | isp_stat_buf_clear(stat); | |
826 | } | |
827 | } | |
828 | ||
829 | spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); | |
830 | mutex_unlock(&stat->ioctl_lock); | |
831 | ||
832 | return 0; | |
833 | } | |
834 | ||
835 | int omap3isp_stat_s_stream(struct v4l2_subdev *subdev, int enable) | |
836 | { | |
837 | struct ispstat *stat = v4l2_get_subdevdata(subdev); | |
838 | ||
839 | if (enable) { | |
840 | /* | |
841 | * Only set enable PCR bit if the module was previously | |
842 | * enabled through ioct. | |
843 | */ | |
844 | isp_stat_try_enable(stat); | |
845 | } else { | |
846 | unsigned long flags; | |
847 | /* Disable PCR bit and config enable field */ | |
848 | omap3isp_stat_enable(stat, 0); | |
849 | spin_lock_irqsave(&stat->isp->stat_lock, flags); | |
850 | stat->ops->enable(stat, 0); | |
851 | spin_unlock_irqrestore(&stat->isp->stat_lock, flags); | |
852 | ||
853 | /* | |
854 | * If module isn't busy, a new interrupt may come or not to | |
855 | * set the state to DISABLED. As Histogram needs to read its | |
856 | * internal memory to clear it, let interrupt handler | |
857 | * responsible of changing state to DISABLED. If the last | |
858 | * interrupt is coming, it's still safe as the handler will | |
859 | * ignore the second time when state is already set to DISABLED. | |
860 | * It's necessary to synchronize Histogram with streamoff, once | |
861 | * the module may be considered idle before last SDMA transfer | |
862 | * starts if we return here. | |
863 | */ | |
864 | if (!omap3isp_stat_pcr_busy(stat)) | |
865 | omap3isp_stat_isr(stat); | |
866 | ||
867 | dev_dbg(stat->isp->dev, "%s: module is being disabled\n", | |
868 | stat->subdev.name); | |
869 | } | |
870 | ||
871 | return 0; | |
872 | } | |
873 | ||
874 | /* | |
875 | * __stat_isr - Interrupt handler for statistic drivers | |
876 | */ | |
877 | static void __stat_isr(struct ispstat *stat, int from_dma) | |
878 | { | |
879 | int ret = STAT_BUF_DONE; | |
880 | int buf_processing; | |
881 | unsigned long irqflags; | |
882 | struct isp_pipeline *pipe; | |
883 | ||
884 | /* | |
885 | * stat->buf_processing must be set before disable module. It's | |
886 | * necessary to not inform too early the buffers aren't busy in case | |
887 | * of SDMA is going to be used. | |
888 | */ | |
889 | spin_lock_irqsave(&stat->isp->stat_lock, irqflags); | |
890 | if (stat->state == ISPSTAT_DISABLED) { | |
891 | spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); | |
892 | return; | |
893 | } | |
894 | buf_processing = stat->buf_processing; | |
895 | stat->buf_processing = 1; | |
896 | stat->ops->enable(stat, 0); | |
897 | ||
898 | if (buf_processing && !from_dma) { | |
899 | if (stat->state == ISPSTAT_ENABLED) { | |
900 | spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); | |
901 | dev_err(stat->isp->dev, | |
902 | "%s: interrupt occurred when module was still " | |
903 | "processing a buffer.\n", stat->subdev.name); | |
904 | ret = STAT_NO_BUF; | |
905 | goto out; | |
906 | } else { | |
907 | /* | |
908 | * Interrupt handler was called from streamoff when | |
909 | * the module wasn't busy anymore to ensure it is being | |
910 | * disabled after process last buffer. If such buffer | |
911 | * processing has already started, no need to do | |
912 | * anything else. | |
913 | */ | |
914 | spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); | |
915 | return; | |
916 | } | |
917 | } | |
918 | spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); | |
919 | ||
920 | /* If it's busy we can't process this buffer anymore */ | |
921 | if (!omap3isp_stat_pcr_busy(stat)) { | |
922 | if (!from_dma && stat->ops->buf_process) | |
923 | /* Module still need to copy data to buffer. */ | |
924 | ret = stat->ops->buf_process(stat); | |
925 | if (ret == STAT_BUF_WAITING_DMA) | |
926 | /* Buffer is not ready yet */ | |
927 | return; | |
928 | ||
929 | spin_lock_irqsave(&stat->isp->stat_lock, irqflags); | |
930 | ||
931 | /* | |
932 | * Histogram needs to read its internal memory to clear it | |
933 | * before be disabled. For that reason, common statistic layer | |
934 | * can return only after call stat's buf_process() operator. | |
935 | */ | |
936 | if (stat->state == ISPSTAT_DISABLING) { | |
937 | stat->state = ISPSTAT_DISABLED; | |
938 | spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); | |
939 | stat->buf_processing = 0; | |
940 | return; | |
941 | } | |
942 | pipe = to_isp_pipeline(&stat->subdev.entity); | |
943 | stat->frame_number = atomic_read(&pipe->frame_number); | |
944 | ||
945 | /* | |
946 | * Before this point, 'ret' stores the buffer's status if it's | |
947 | * ready to be processed. Afterwards, it holds the status if | |
948 | * it was processed successfully. | |
949 | */ | |
950 | ret = isp_stat_buf_process(stat, ret); | |
951 | ||
952 | if (likely(!stat->sbl_ovl_recover)) { | |
953 | stat->ops->setup_regs(stat, stat->priv); | |
954 | } else { | |
955 | /* | |
956 | * Using recover config to increase the chance to have | |
957 | * a good buffer processing and make the H3A module to | |
958 | * go back to a valid state. | |
959 | */ | |
960 | stat->update = 1; | |
961 | stat->ops->setup_regs(stat, stat->recover_priv); | |
962 | stat->sbl_ovl_recover = 0; | |
963 | ||
964 | /* | |
965 | * Set 'update' in case of the module needs to use | |
966 | * regular configuration after next buffer. | |
967 | */ | |
968 | stat->update = 1; | |
969 | } | |
970 | ||
971 | isp_stat_buf_insert_magic(stat, stat->active_buf); | |
972 | ||
973 | /* | |
974 | * Hack: H3A modules may access invalid memory address or send | |
975 | * corrupted data to userspace if more than 1 SBL overflow | |
976 | * happens in a row without re-writing its buffer's start memory | |
977 | * address in the meantime. Such situation is avoided if the | |
978 | * module is not immediately re-enabled when the ISR misses the | |
979 | * timing to process the buffer and to setup the registers. | |
980 | * Because of that, pcr_enable(1) was moved to inside this 'if' | |
981 | * block. But the next interruption will still happen as during | |
982 | * pcr_enable(0) the module was busy. | |
983 | */ | |
984 | isp_stat_pcr_enable(stat, 1); | |
985 | spin_unlock_irqrestore(&stat->isp->stat_lock, irqflags); | |
986 | } else { | |
987 | /* | |
988 | * If a SBL overflow occurs and the H3A driver misses the timing | |
989 | * to process the buffer, stat->buf_err is set and won't be | |
990 | * cleared now. So the next buffer will be correctly ignored. | |
991 | * It's necessary due to a hw issue which makes the next H3A | |
992 | * buffer to start from the memory address where the previous | |
993 | * one stopped, instead of start where it was configured to. | |
994 | * Do not "stat->buf_err = 0" here. | |
995 | */ | |
996 | ||
997 | if (stat->ops->buf_process) | |
998 | /* | |
999 | * Driver may need to erase current data prior to | |
1000 | * process a new buffer. If it misses the timing, the | |
1001 | * next buffer might be wrong. So should be ignored. | |
1002 | * It happens only for Histogram. | |
1003 | */ | |
1004 | atomic_set(&stat->buf_err, 1); | |
1005 | ||
1006 | ret = STAT_NO_BUF; | |
1007 | dev_dbg(stat->isp->dev, "%s: cannot process buffer, " | |
1008 | "device is busy.\n", stat->subdev.name); | |
1009 | } | |
1010 | ||
1011 | out: | |
1012 | stat->buf_processing = 0; | |
1013 | isp_stat_queue_event(stat, ret != STAT_BUF_DONE); | |
1014 | } | |
1015 | ||
1016 | void omap3isp_stat_isr(struct ispstat *stat) | |
1017 | { | |
1018 | __stat_isr(stat, 0); | |
1019 | } | |
1020 | ||
1021 | void omap3isp_stat_dma_isr(struct ispstat *stat) | |
1022 | { | |
1023 | __stat_isr(stat, 1); | |
1024 | } | |
1025 | ||
68e342b3 DC |
1026 | int omap3isp_stat_subscribe_event(struct v4l2_subdev *subdev, |
1027 | struct v4l2_fh *fh, | |
1028 | struct v4l2_event_subscription *sub) | |
1029 | { | |
1030 | struct ispstat *stat = v4l2_get_subdevdata(subdev); | |
1031 | ||
1032 | if (sub->type != stat->event_type) | |
1033 | return -EINVAL; | |
1034 | ||
f1e393de | 1035 | return v4l2_event_subscribe(fh, sub, STAT_NEVENTS); |
68e342b3 DC |
1036 | } |
1037 | ||
1038 | int omap3isp_stat_unsubscribe_event(struct v4l2_subdev *subdev, | |
1039 | struct v4l2_fh *fh, | |
1040 | struct v4l2_event_subscription *sub) | |
1041 | { | |
1042 | return v4l2_event_unsubscribe(fh, sub); | |
1043 | } | |
1044 | ||
1045 | void omap3isp_stat_unregister_entities(struct ispstat *stat) | |
1046 | { | |
68e342b3 DC |
1047 | v4l2_device_unregister_subdev(&stat->subdev); |
1048 | } | |
1049 | ||
1050 | int omap3isp_stat_register_entities(struct ispstat *stat, | |
1051 | struct v4l2_device *vdev) | |
1052 | { | |
1053 | return v4l2_device_register_subdev(vdev, &stat->subdev); | |
1054 | } | |
1055 | ||
39099d09 LP |
1056 | static int isp_stat_init_entities(struct ispstat *stat, const char *name, |
1057 | const struct v4l2_subdev_ops *sd_ops) | |
1058 | { | |
1059 | struct v4l2_subdev *subdev = &stat->subdev; | |
1060 | struct media_entity *me = &subdev->entity; | |
1061 | ||
1062 | v4l2_subdev_init(subdev, sd_ops); | |
1063 | snprintf(subdev->name, V4L2_SUBDEV_NAME_SIZE, "OMAP3 ISP %s", name); | |
1064 | subdev->grp_id = 1 << 16; /* group ID for isp subdevs */ | |
1065 | subdev->flags |= V4L2_SUBDEV_FL_HAS_EVENTS | V4L2_SUBDEV_FL_HAS_DEVNODE; | |
1066 | v4l2_set_subdevdata(subdev, stat); | |
1067 | ||
1068 | stat->pad.flags = MEDIA_PAD_FL_SINK; | |
1069 | me->ops = NULL; | |
1070 | ||
1071 | return media_entity_init(me, 1, &stat->pad, 0); | |
1072 | } | |
1073 | ||
68e342b3 DC |
1074 | int omap3isp_stat_init(struct ispstat *stat, const char *name, |
1075 | const struct v4l2_subdev_ops *sd_ops) | |
1076 | { | |
1077 | stat->buf = kcalloc(STAT_MAX_BUFS, sizeof(*stat->buf), GFP_KERNEL); | |
1078 | if (!stat->buf) | |
1079 | return -ENOMEM; | |
1080 | isp_stat_buf_clear(stat); | |
1081 | mutex_init(&stat->ioctl_lock); | |
1082 | atomic_set(&stat->buf_err, 0); | |
1083 | ||
1084 | return isp_stat_init_entities(stat, name, sd_ops); | |
1085 | } | |
1086 | ||
63b4ca23 | 1087 | void omap3isp_stat_cleanup(struct ispstat *stat) |
68e342b3 | 1088 | { |
63b4ca23 | 1089 | media_entity_cleanup(&stat->subdev.entity); |
68e342b3 DC |
1090 | isp_stat_bufs_free(stat); |
1091 | kfree(stat->buf); | |
1092 | } |