← Back to branch summary

~ubuntu-branches/ubuntu/quantal/linux-linaro-mx51/quantal

« back to all changes in this revision

Viewing changes to arch/m68k/include/asm/bitops_mm.h

  • Committer: Package Import Robot
  • Author(s): John Rigby, John Rigby
  • Date: 2011-09-26 10:44:23 UTC
  • Revision ID: package-import@ubuntu.com-20110926104423-3o58a3c1bj7x00rs
Tags: 3.0.0-1007.9
https://launchpad.net/bugs/826021
[ John Rigby ]

Enable crypto modules and remove crypto-modules from
exclude-module files
LP: #826021

Show diffs side-by-side

added added

removed removed

Lines of Context:
arch/m68k/include/asm/bitops_mm.h
181
181
{
182
182
        const unsigned long *p = vaddr;
183
183
        int res = 32;
 
184
        unsigned int words;
184
185
        unsigned long num;
185
186
 
186
187
        if (!size)
187
188
                return 0;
188
189
 
189
 
        size = (size + 31) >> 5;
 
190
        words = (size + 31) >> 5;
190
191
        while (!(num = ~*p++)) {
191
 
                if (!--size)
 
192
                if (!--words)
192
193
                        goto out;
193
194
        }
194
195
 
196
197
                              : "=d" (res) : "d" (num & -num));
197
198
        res ^= 31;
198
199
out:
199
 
        return ((long)p - (long)vaddr - 4) * 8 + res;
 
200
        res += ((long)p - (long)vaddr - 4) * 8;
 
201
        return res < size ? res : size;
200
202
}
 
203
#define find_first_zero_bit find_first_zero_bit
201
204
 
202
205
static inline int find_next_zero_bit(const unsigned long *vaddr, int size,
203
206
                                     int offset)
215
218
                /* Look for zero in first longword */
216
219
                __asm__ __volatile__ ("bfffo %1{#0,#0},%0"
217
220
                                      : "=d" (res) : "d" (num & -num));
218
 
                if (res < 32)
219
 
                        return offset + (res ^ 31);
 
221
                if (res < 32) {
 
222
                        offset += res ^ 31;
 
223
                        return offset < size ? offset : size;
 
224
                }
220
225
                offset += 32;
 
226
 
 
227
                if (offset >= size)
 
228
                        return size;
221
229
        }
222
230
        /* No zero yet, search remaining full bytes for a zero */
223
 
        res = find_first_zero_bit(p, size - ((long)p - (long)vaddr) * 8);
224
 
        return offset + res;
 
231
        return offset + find_first_zero_bit(p, size - offset);
225
232
}
 
233
#define find_next_zero_bit find_next_zero_bit
226
234
 
227
235
static inline int find_first_bit(const unsigned long *vaddr, unsigned size)
228
236
{
229
237
        const unsigned long *p = vaddr;
230
238
        int res = 32;
 
239
        unsigned int words;
231
240
        unsigned long num;
232
241
 
233
242
        if (!size)
234
243
                return 0;
235
244
 
236
 
        size = (size + 31) >> 5;
 
245
        words = (size + 31) >> 5;
237
246
        while (!(num = *p++)) {
238
 
                if (!--size)
 
247
                if (!--words)
239
248
                        goto out;
240
249
        }
241
250
 
243
252
                              : "=d" (res) : "d" (num & -num));
244
253
        res ^= 31;
245
254
out:
246
 
        return ((long)p - (long)vaddr - 4) * 8 + res;
 
255
        res += ((long)p - (long)vaddr - 4) * 8;
 
256
        return res < size ? res : size;
247
257
}
 
258
#define find_first_bit find_first_bit
248
259
 
249
260
static inline int find_next_bit(const unsigned long *vaddr, int size,
250
261
                                int offset)
262
273
                /* Look for one in first longword */
263
274
                __asm__ __volatile__ ("bfffo %1{#0,#0},%0"
264
275
                                      : "=d" (res) : "d" (num & -num));
265
 
                if (res < 32)
266
 
                        return offset + (res ^ 31);
 
276
                if (res < 32) {
 
277
                        offset += res ^ 31;
 
278
                        return offset < size ? offset : size;
 
279
                }
267
280
                offset += 32;
 
281
 
 
282
                if (offset >= size)
 
283
                        return size;
268
284
        }
269
285
        /* No one yet, search remaining full bytes for a one */
270
 
        res = find_first_bit(p, size - ((long)p - (long)vaddr) * 8);
271
 
        return offset + res;
 
286
        return offset + find_first_bit(p, size - offset);
272
287
}
 
288
#define find_next_bit find_next_bit
273
289
 
274
290
/*
275
291
 * ffz = Find First Zero in word. Undefined if no zero exists,
366
382
static inline int find_first_zero_bit_le(const void *vaddr, unsigned size)
367
383
{
368
384
        const unsigned long *p = vaddr, *addr = vaddr;
369
 
        int res;
 
385
        int res = 0;
 
386
        unsigned int words;
370
387
 
371
388
        if (!size)
372
389
                return 0;
373
390
 
374
 
        size = (size >> 5) + ((size & 31) > 0);
375
 
        while (*p++ == ~0UL)
376
 
        {
377
 
                if (--size == 0)
378
 
                        return (p - addr) << 5;
 
391
        words = (size >> 5) + ((size & 31) > 0);
 
392
        while (*p++ == ~0UL) {
 
393
                if (--words == 0)
 
394
                        goto out;
379
395
        }
380
396
 
381
397
        --p;
382
398
        for (res = 0; res < 32; res++)
383
399
                if (!test_bit_le(res, p))
384
400
                        break;
385
 
        return (p - addr) * 32 + res;
 
401
out:
 
402
        res += (p - addr) * 32;
 
403
        return res < size ? res : size;
386
404
}
 
405
#define find_first_zero_bit_le find_first_zero_bit_le
387
406
 
388
407
static inline unsigned long find_next_zero_bit_le(const void *addr,
389
408
                unsigned long size, unsigned long offset)
400
419
                offset -= bit;
401
420
                /* Look for zero in first longword */
402
421
                for (res = bit; res < 32; res++)
403
 
                        if (!test_bit_le(res, p))
404
 
                                return offset + res;
 
422
                        if (!test_bit_le(res, p)) {
 
423
                                offset += res;
 
424
                                return offset < size ? offset : size;
 
425
                        }
405
426
                p++;
406
427
                offset += 32;
 
428
 
 
429
                if (offset >= size)
 
430
                        return size;
407
431
        }
408
432
        /* No zero yet, search remaining full bytes for a zero */
409
433
        return offset + find_first_zero_bit_le(p, size - offset);
410
434
}
 
435
#define find_next_zero_bit_le find_next_zero_bit_le
411
436
 
412
437
static inline int find_first_bit_le(const void *vaddr, unsigned size)
413
438
{
414
439
        const unsigned long *p = vaddr, *addr = vaddr;
415
 
        int res;
 
440
        int res = 0;
 
441
        unsigned int words;
416
442
 
417
443
        if (!size)
418
444
                return 0;
419
445
 
420
 
        size = (size >> 5) + ((size & 31) > 0);
 
446
        words = (size >> 5) + ((size & 31) > 0);
421
447
        while (*p++ == 0UL) {
422
 
                if (--size == 0)
423
 
                        return (p - addr) << 5;
 
448
                if (--words == 0)
 
449
                        goto out;
424
450
        }
425
451
 
426
452
        --p;
427
453
        for (res = 0; res < 32; res++)
428
454
                if (test_bit_le(res, p))
429
455
                        break;
430
 
        return (p - addr) * 32 + res;
 
456
out:
 
457
        res += (p - addr) * 32;
 
458
        return res < size ? res : size;
431
459
}
 
460
#define find_first_bit_le find_first_bit_le
432
461
 
433
462
static inline unsigned long find_next_bit_le(const void *addr,
434
463
                unsigned long size, unsigned long offset)
445
474
                offset -= bit;
446
475
                /* Look for one in first longword */
447
476
                for (res = bit; res < 32; res++)
448
 
                        if (test_bit_le(res, p))
449
 
                                return offset + res;
 
477
                        if (test_bit_le(res, p)) {
 
478
                                offset += res;
 
479
                                return offset < size ? offset : size;
 
480
                        }
450
481
                p++;
451
482
                offset += 32;
 
483
 
 
484
                if (offset >= size)
 
485
                        return size;
452
486
        }
453
487
        /* No set bit yet, search remaining full bytes for a set bit */
454
488
        return offset + find_first_bit_le(p, size - offset);
455
489
}
 
490
#define find_next_bit_le find_next_bit_le
456
491
 
457
492
/* Bitmap functions for the ext2 filesystem. */
458
493