Showing error 750

User: Jiri Slaby
Error type: Invalid Pointer Dereference
Error type description: A pointer which is invalid is being dereferenced
File location: drivers/media/video/pvrusb2/pvrusb2-std.c
Line in file: 373
Project: Linux Kernel
Project version: 2.6.28
Tools: Stanse (1.2)
Smatch (1.59)
Entered: 2011-11-07 22:22:22 UTC

Source: 

  1/*
  2 *
  3 *
  4 *  Copyright (C) 2005 Mike Isely <isely@pobox.com>
  5 *
  6 *  This program is free software; you can redistribute it and/or modify
  7 *  it under the terms of the GNU General Public License as published by
  8 *  the Free Software Foundation; either version 2 of the License
  9 *
 10 *  This program is distributed in the hope that it will be useful,
 11 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 *  GNU General Public License for more details.
 14 *
 15 *  You should have received a copy of the GNU General Public License
 16 *  along with this program; if not, write to the Free Software
 17 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 18 *
 19 */
 20
 21#include "pvrusb2-std.h"
 22#include "pvrusb2-debug.h"
 23#include <asm/string.h>
 24#include <linux/slab.h>
 25
 26struct std_name {
 27        const char *name;
 28        v4l2_std_id id;
 29};
 30
 31
 32#define CSTD_PAL \
 33        (V4L2_STD_PAL_B| \
 34         V4L2_STD_PAL_B1| \
 35         V4L2_STD_PAL_G| \
 36         V4L2_STD_PAL_H| \
 37         V4L2_STD_PAL_I| \
 38         V4L2_STD_PAL_D| \
 39         V4L2_STD_PAL_D1| \
 40         V4L2_STD_PAL_K| \
 41         V4L2_STD_PAL_M| \
 42         V4L2_STD_PAL_N| \
 43         V4L2_STD_PAL_Nc| \
 44         V4L2_STD_PAL_60)
 45
 46#define CSTD_NTSC \
 47        (V4L2_STD_NTSC_M| \
 48         V4L2_STD_NTSC_M_JP| \
 49         V4L2_STD_NTSC_M_KR| \
 50         V4L2_STD_NTSC_443)
 51
 52#define CSTD_ATSC \
 53        (V4L2_STD_ATSC_8_VSB| \
 54         V4L2_STD_ATSC_16_VSB)
 55
 56#define CSTD_SECAM \
 57        (V4L2_STD_SECAM_B| \
 58         V4L2_STD_SECAM_D| \
 59         V4L2_STD_SECAM_G| \
 60         V4L2_STD_SECAM_H| \
 61         V4L2_STD_SECAM_K| \
 62         V4L2_STD_SECAM_K1| \
 63         V4L2_STD_SECAM_L| \
 64         V4L2_STD_SECAM_LC)
 65
 66#define TSTD_B   (V4L2_STD_PAL_B|V4L2_STD_SECAM_B)
 67#define TSTD_B1  (V4L2_STD_PAL_B1)
 68#define TSTD_D   (V4L2_STD_PAL_D|V4L2_STD_SECAM_D)
 69#define TSTD_D1  (V4L2_STD_PAL_D1)
 70#define TSTD_G   (V4L2_STD_PAL_G|V4L2_STD_SECAM_G)
 71#define TSTD_H   (V4L2_STD_PAL_H|V4L2_STD_SECAM_H)
 72#define TSTD_I   (V4L2_STD_PAL_I)
 73#define TSTD_K   (V4L2_STD_PAL_K|V4L2_STD_SECAM_K)
 74#define TSTD_K1  (V4L2_STD_SECAM_K1)
 75#define TSTD_L   (V4L2_STD_SECAM_L)
 76#define TSTD_M   (V4L2_STD_PAL_M|V4L2_STD_NTSC_M)
 77#define TSTD_N   (V4L2_STD_PAL_N)
 78#define TSTD_Nc  (V4L2_STD_PAL_Nc)
 79#define TSTD_60  (V4L2_STD_PAL_60)
 80
 81#define CSTD_ALL (CSTD_PAL|CSTD_NTSC|CSTD_ATSC|CSTD_SECAM)
 82
 83/* Mapping of standard bits to color system */
 84static const struct std_name std_groups[] = {
 85        {"PAL",CSTD_PAL},
 86        {"NTSC",CSTD_NTSC},
 87        {"SECAM",CSTD_SECAM},
 88        {"ATSC",CSTD_ATSC},
 89};
 90
 91/* Mapping of standard bits to modulation system */
 92static const struct std_name std_items[] = {
 93        {"B",TSTD_B},
 94        {"B1",TSTD_B1},
 95        {"D",TSTD_D},
 96        {"D1",TSTD_D1},
 97        {"G",TSTD_G},
 98        {"H",TSTD_H},
 99        {"I",TSTD_I},
100        {"K",TSTD_K},
101        {"K1",TSTD_K1},
102        {"L",TSTD_L},
103        {"LC",V4L2_STD_SECAM_LC},
104        {"M",TSTD_M},
105        {"Mj",V4L2_STD_NTSC_M_JP},
106        {"443",V4L2_STD_NTSC_443},
107        {"Mk",V4L2_STD_NTSC_M_KR},
108        {"N",TSTD_N},
109        {"Nc",TSTD_Nc},
110        {"60",TSTD_60},
111        {"8VSB",V4L2_STD_ATSC_8_VSB},
112        {"16VSB",V4L2_STD_ATSC_16_VSB},
113};
114
115
116// Search an array of std_name structures and return a pointer to the
117// element with the matching name.
118static const struct std_name *find_std_name(const struct std_name *arrPtr,
119                                            unsigned int arrSize,
120                                            const char *bufPtr,
121                                            unsigned int bufSize)
122{
123        unsigned int idx;
124        const struct std_name *p;
125        for (idx = 0; idx < arrSize; idx++) {
126                p = arrPtr + idx;
127                if (strlen(p->name) != bufSize) continue;
128                if (!memcmp(bufPtr,p->name,bufSize)) return p;
129        }
130        return NULL;
131}
132
133
134int pvr2_std_str_to_id(v4l2_std_id *idPtr,const char *bufPtr,
135                       unsigned int bufSize)
136{
137        v4l2_std_id id = 0;
138        v4l2_std_id cmsk = 0;
139        v4l2_std_id t;
140        int mMode = 0;
141        unsigned int cnt;
142        char ch;
143        const struct std_name *sp;
144
145        while (bufSize) {
146                if (!mMode) {
147                        cnt = 0;
148                        while ((cnt < bufSize) && (bufPtr[cnt] != '-')) cnt++;
149                        if (cnt >= bufSize) return 0; // No more characters
150                        sp = find_std_name(std_groups, ARRAY_SIZE(std_groups),
151                                           bufPtr,cnt);
152                        if (!sp) return 0; // Illegal color system name
153                        cnt++;
154                        bufPtr += cnt;
155                        bufSize -= cnt;
156                        mMode = !0;
157                        cmsk = sp->id;
158                        continue;
159                }
160                cnt = 0;
161                while (cnt < bufSize) {
162                        ch = bufPtr[cnt];
163                        if (ch == ';') {
164                                mMode = 0;
165                                break;
166                        }
167                        if (ch == '/') break;
168                        cnt++;
169                }
170                sp = find_std_name(std_items, ARRAY_SIZE(std_items),
171                                   bufPtr,cnt);
172                if (!sp) return 0; // Illegal modulation system ID
173                t = sp->id & cmsk;
174                if (!t) return 0; // Specific color + modulation system illegal
175                id |= t;
176                if (cnt < bufSize) cnt++;
177                bufPtr += cnt;
178                bufSize -= cnt;
179        }
180
181        if (idPtr) *idPtr = id;
182        return !0;
183}
184
185
186unsigned int pvr2_std_id_to_str(char *bufPtr, unsigned int bufSize,
187                                v4l2_std_id id)
188{
189        unsigned int idx1,idx2;
190        const struct std_name *ip,*gp;
191        int gfl,cfl;
192        unsigned int c1,c2;
193        cfl = 0;
194        c1 = 0;
195        for (idx1 = 0; idx1 < ARRAY_SIZE(std_groups); idx1++) {
196                gp = std_groups + idx1;
197                gfl = 0;
198                for (idx2 = 0; idx2 < ARRAY_SIZE(std_items); idx2++) {
199                        ip = std_items + idx2;
200                        if (!(gp->id & ip->id & id)) continue;
201                        if (!gfl) {
202                                if (cfl) {
203                                        c2 = scnprintf(bufPtr,bufSize,";");
204                                        c1 += c2;
205                                        bufSize -= c2;
206                                        bufPtr += c2;
207                                }
208                                cfl = !0;
209                                c2 = scnprintf(bufPtr,bufSize,
210                                               "%s-",gp->name);
211                                gfl = !0;
212                        } else {
213                                c2 = scnprintf(bufPtr,bufSize,"/");
214                        }
215                        c1 += c2;
216                        bufSize -= c2;
217                        bufPtr += c2;
218                        c2 = scnprintf(bufPtr,bufSize,
219                                       ip->name);
220                        c1 += c2;
221                        bufSize -= c2;
222                        bufPtr += c2;
223                }
224        }
225        return c1;
226}
227
228
229// Template data for possible enumerated video standards.  Here we group
230// standards which share common frame rates and resolution.
231static struct v4l2_standard generic_standards[] = {
232        {
233                .id             = (TSTD_B|TSTD_B1|
234                                   TSTD_D|TSTD_D1|
235                                   TSTD_G|
236                                   TSTD_H|
237                                   TSTD_I|
238                                   TSTD_K|TSTD_K1|
239                                   TSTD_L|
240                                   V4L2_STD_SECAM_LC |
241                                   TSTD_N|TSTD_Nc),
242                .frameperiod    =
243                {
244                        .numerator  = 1,
245                        .denominator= 25
246                },
247                .framelines     = 625,
248                .reserved       = {0,0,0,0}
249        }, {
250                .id             = (TSTD_M|
251                                   V4L2_STD_NTSC_M_JP|
252                                   V4L2_STD_NTSC_M_KR),
253                .frameperiod    =
254                {
255                        .numerator  = 1001,
256                        .denominator= 30000
257                },
258                .framelines     = 525,
259                .reserved       = {0,0,0,0}
260        }, { // This is a total wild guess
261                .id             = (TSTD_60),
262                .frameperiod    =
263                {
264                        .numerator  = 1001,
265                        .denominator= 30000
266                },
267                .framelines     = 525,
268                .reserved       = {0,0,0,0}
269        }, { // This is total wild guess
270                .id             = V4L2_STD_NTSC_443,
271                .frameperiod    =
272                {
273                        .numerator  = 1001,
274                        .denominator= 30000
275                },
276                .framelines     = 525,
277                .reserved       = {0,0,0,0}
278        }
279};
280
281#define generic_standards_cnt ARRAY_SIZE(generic_standards)
282
283static struct v4l2_standard *match_std(v4l2_std_id id)
284{
285        unsigned int idx;
286        for (idx = 0; idx < generic_standards_cnt; idx++) {
287                if (generic_standards[idx].id & id) {
288                        return generic_standards + idx;
289                }
290        }
291        return NULL;
292}
293
294static int pvr2_std_fill(struct v4l2_standard *std,v4l2_std_id id)
295{
296        struct v4l2_standard *template;
297        int idx;
298        unsigned int bcnt;
299        template = match_std(id);
300        if (!template) return 0;
301        idx = std->index;
302        memcpy(std,template,sizeof(*template));
303        std->index = idx;
304        std->id = id;
305        bcnt = pvr2_std_id_to_str(std->name,sizeof(std->name)-1,id);
306        std->name[bcnt] = 0;
307        pvr2_trace(PVR2_TRACE_STD,"Set up standard idx=%u name=%s",
308                   std->index,std->name);
309        return !0;
310}
311
312/* These are special cases of combined standards that we should enumerate
313   separately if the component pieces are present. */
314static v4l2_std_id std_mixes[] = {
315        V4L2_STD_PAL_B | V4L2_STD_PAL_G,
316        V4L2_STD_PAL_D | V4L2_STD_PAL_K,
317        V4L2_STD_SECAM_B | V4L2_STD_SECAM_G,
318        V4L2_STD_SECAM_D | V4L2_STD_SECAM_K,
319};
320
321struct v4l2_standard *pvr2_std_create_enum(unsigned int *countptr,
322                                           v4l2_std_id id)
323{
324        unsigned int std_cnt = 0;
325        unsigned int idx,bcnt,idx2;
326        v4l2_std_id idmsk,cmsk,fmsk;
327        struct v4l2_standard *stddefs;
328
329        if (pvrusb2_debug & PVR2_TRACE_STD) {
330                char buf[100];
331                bcnt = pvr2_std_id_to_str(buf,sizeof(buf),id);
332                pvr2_trace(
333                        PVR2_TRACE_STD,"Mapping standards mask=0x%x (%.*s)",
334                        (int)id,bcnt,buf);
335        }
336
337        *countptr = 0;
338        std_cnt = 0;
339        fmsk = 0;
340        for (idmsk = 1, cmsk = id; cmsk; idmsk <<= 1) {
341                if (!(idmsk & cmsk)) continue;
342                cmsk &= ~idmsk;
343                if (match_std(idmsk)) {
344                        std_cnt++;
345                        continue;
346                }
347                fmsk |= idmsk;
348        }
349
350        for (idx2 = 0; idx2 < ARRAY_SIZE(std_mixes); idx2++) {
351                if ((id & std_mixes[idx2]) == std_mixes[idx2]) std_cnt++;
352        }
353
354        /* Don't complain about ATSC standard values */
355        fmsk &= ~CSTD_ATSC;
356
357        if (fmsk) {
358                char buf[100];
359                bcnt = pvr2_std_id_to_str(buf,sizeof(buf),fmsk);
360                pvr2_trace(
361                        PVR2_TRACE_ERROR_LEGS,
362                        "WARNING:"
363                        " Failed to classify the following standard(s): %.*s",
364                        bcnt,buf);
365        }
366
367        pvr2_trace(PVR2_TRACE_STD,"Setting up %u unique standard(s)",
368                   std_cnt);
369        if (!std_cnt) return NULL; // paranoia
370
371        stddefs = kzalloc(sizeof(struct v4l2_standard) * std_cnt,
372                          GFP_KERNEL);
373        for (idx = 0; idx < std_cnt; idx++) stddefs[idx].index = idx;
374
375        idx = 0;
376
377        /* Enumerate potential special cases */
378        for (idx2 = 0; (idx2 < ARRAY_SIZE(std_mixes)) && (idx < std_cnt);
379             idx2++) {
380                if (!(id & std_mixes[idx2])) continue;
381                if (pvr2_std_fill(stddefs+idx,std_mixes[idx2])) idx++;
382        }
383        /* Now enumerate individual pieces */
384        for (idmsk = 1, cmsk = id; cmsk && (idx < std_cnt); idmsk <<= 1) {
385                if (!(idmsk & cmsk)) continue;
386                cmsk &= ~idmsk;
387                if (!pvr2_std_fill(stddefs+idx,idmsk)) continue;
388                idx++;
389        }
390
391        *countptr = std_cnt;
392        return stddefs;
393}
394
395v4l2_std_id pvr2_std_get_usable(void)
396{
397        return CSTD_ALL;
398}
399
400
401/*
402  Stuff for Emacs to see, in order to encourage consistent editing style:
403  *** Local Variables: ***
404  *** mode: c ***
405  *** fill-column: 75 ***
406  *** tab-width: 8 ***
407  *** c-basic-offset: 8 ***
408  *** End: ***
409  */
↑