kernel/arch/arc/include/asm/bitops.h

   1 /*
   2  * Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  */
   8
   9 #ifndef _ASM_BITOPS_H
  10 #define _ASM_BITOPS_H
  11
  12 #ifndef _LINUX_BITOPS_H
  13 #error only <linux/bitops.h> can be included directly
  14 #endif
  15
  16 #ifndef __ASSEMBLY__
  17
  18 #include <linux/types.h>
  19 #include <linux/compiler.h>
  20 #include <asm/barrier.h>
  21
  22 /*
  23  * Hardware assisted read-modify-write using ARC700 LLOCK/SCOND insns.
  24  * The Kconfig glue ensures that in SMP, this is only set if the container
  25  * SoC/platform has cross-core coherent LLOCK/SCOND
  26  */
  27 #if defined(CONFIG_ARC_HAS_LLSC)
  28
  29 static inline void set_bit(unsigned long nr, volatile unsigned long *m)
  30 {
  31         unsigned int temp;
  32
  33         m += nr >> 5;
  34
  35         /*
  36          * ARC ISA micro-optimization:
  37          *
  38          * Instructions dealing with bitpos only consider lower 5 bits (0-31)
  39          * e.g (x << 33) is handled like (x << 1) by ASL instruction
  40          *  (mem pointer still needs adjustment to point to next word)
  41          *
  42          * Hence the masking to clamp @nr arg can be elided in general.
  43          *
  44          * However if @nr is a constant (above assumed it in a register),
  45          * and greater than 31, gcc can optimize away (x << 33) to 0,
  46          * as overflow, given the 32-bit ISA. Thus masking needs to be done
  47          * for constant @nr, but no code is generated due to const prop.
  48          */
  49         if (__builtin_constant_p(nr))
  50                 nr &= 0x1f;
  51
  52         __asm__ __volatile__(
  53         "1:     llock   %0, [%1]        \n"
  54         "       bset    %0, %0, %2      \n"
  55         "       scond   %0, [%1]        \n"
  56         "       bnz     1b      \n"
  57         : "=&r"(temp)
  58         : "r"(m), "ir"(nr)
  59         : "cc");
  60 }
  61
  62 static inline void clear_bit(unsigned long nr, volatile unsigned long *m)
  63 {
  64         unsigned int temp;
  65
  66         m += nr >> 5;
  67
  68         if (__builtin_constant_p(nr))
  69                 nr &= 0x1f;
  70
  71         __asm__ __volatile__(
  72         "1:     llock   %0, [%1]        \n"
  73         "       bclr    %0, %0, %2      \n"
  74         "       scond   %0, [%1]        \n"
  75         "       bnz     1b      \n"
  76         : "=&r"(temp)
  77         : "r"(m), "ir"(nr)
  78         : "cc");
  79 }
  80
  81 static inline void change_bit(unsigned long nr, volatile unsigned long *m)
  82 {
  83         unsigned int temp;
  84
  85         m += nr >> 5;
  86
  87         if (__builtin_constant_p(nr))
  88                 nr &= 0x1f;
  89
  90         __asm__ __volatile__(
  91         "1:     llock   %0, [%1]        \n"
  92         "       bxor    %0, %0, %2      \n"
  93         "       scond   %0, [%1]        \n"
  94         "       bnz     1b              \n"
  95         : "=&r"(temp)
  96         : "r"(m), "ir"(nr)
  97         : "cc");
  98 }
  99
 100 /*
 101  * Semantically:
 102  *    Test the bit
 103  *    if clear
 104  *        set it and return 0 (old value)
 105  *    else
 106  *        return 1 (old value).
 107  *
 108  * Since ARC lacks a equivalent h/w primitive, the bit is set unconditionally
 109  * and the old value of bit is returned
 110  */
 111 static inline int test_and_set_bit(unsigned long nr, volatile unsigned long *m)
 112 {
 113         unsigned long old, temp;
 114
 115         m += nr >> 5;
 116
 117         if (__builtin_constant_p(nr))
 118                 nr &= 0x1f;
 119
 120         /*
 121          * Explicit full memory barrier needed before/after as
 122          * LLOCK/SCOND themselves don't provide any such semantics
 123          */
 124         smp_mb();
 125
 126         __asm__ __volatile__(
 127         "1:     llock   %0, [%2]        \n"
 128         "       bset    %1, %0, %3      \n"
 129         "       scond   %1, [%2]        \n"
 130         "       bnz     1b              \n"
 131         : "=&r"(old), "=&r"(temp)
 132         : "r"(m), "ir"(nr)
 133         : "cc");
 134
 135         smp_mb();
 136
 137         return (old & (1 << nr)) != 0;
 138 }
 139
 140 static inline int
 141 test_and_clear_bit(unsigned long nr, volatile unsigned long *m)
 142 {
 143         unsigned int old, temp;
 144
 145         m += nr >> 5;
 146
 147         if (__builtin_constant_p(nr))
 148                 nr &= 0x1f;
 149
 150         smp_mb();
 151
 152         __asm__ __volatile__(
 153         "1:     llock   %0, [%2]        \n"
 154         "       bclr    %1, %0, %3      \n"
 155         "       scond   %1, [%2]        \n"
 156         "       bnz     1b              \n"
 157         : "=&r"(old), "=&r"(temp)
 158         : "r"(m), "ir"(nr)
 159         : "cc");
 160
 161         smp_mb();
 162
 163         return (old & (1 << nr)) != 0;
 164 }
 165
 166 static inline int
 167 test_and_change_bit(unsigned long nr, volatile unsigned long *m)
 168 {
 169         unsigned int old, temp;
 170
 171         m += nr >> 5;
 172
 173         if (__builtin_constant_p(nr))
 174                 nr &= 0x1f;
 175
 176         smp_mb();
 177
 178         __asm__ __volatile__(
 179         "1:     llock   %0, [%2]        \n"
 180         "       bxor    %1, %0, %3      \n"
 181         "       scond   %1, [%2]        \n"
 182         "       bnz     1b              \n"
 183         : "=&r"(old), "=&r"(temp)
 184         : "r"(m), "ir"(nr)
 185         : "cc");
 186
 187         smp_mb();
 188
 189         return (old & (1 << nr)) != 0;
 190 }
 191
 192 #else   /* !CONFIG_ARC_HAS_LLSC */
 193
 194 #include <asm/smp.h>
 195
 196 /*
 197  * Non hardware assisted Atomic-R-M-W
 198  * Locking would change to irq-disabling only (UP) and spinlocks (SMP)
 199  *
 200  * There's "significant" micro-optimization in writing our own variants of
 201  * bitops (over generic variants)
 202  *
 203  * (1) The generic APIs have "signed" @nr while we have it "unsigned"
 204  *     This avoids extra code to be generated for pointer arithmatic, since
 205  *     is "not sure" that index is NOT -ve
 206  * (2) Utilize the fact that ARCompact bit fidding insn (BSET/BCLR/ASL) etc
 207  *     only consider bottom 5 bits of @nr, so NO need to mask them off.
 208  *     (GCC Quirk: however for constant @nr we still need to do the masking
 209  *             at compile time)
 210  */
 211
 212 static inline void set_bit(unsigned long nr, volatile unsigned long *m)
 213 {
 214         unsigned long temp, flags;
 215         m += nr >> 5;
 216
 217         if (__builtin_constant_p(nr))
 218                 nr &= 0x1f;
 219
 220         bitops_lock(flags);
 221
 222         temp = *m;
 223         *m = temp | (1UL << nr);
 224
 225         bitops_unlock(flags);
 226 }
 227
 228 static inline void clear_bit(unsigned long nr, volatile unsigned long *m)
 229 {
 230         unsigned long temp, flags;
 231         m += nr >> 5;
 232
 233         if (__builtin_constant_p(nr))
 234                 nr &= 0x1f;
 235
 236         bitops_lock(flags);
 237
 238         temp = *m;
 239         *m = temp & ~(1UL << nr);
 240
 241         bitops_unlock(flags);
 242 }
 243
 244 static inline void change_bit(unsigned long nr, volatile unsigned long *m)
 245 {
 246         unsigned long temp, flags;
 247         m += nr >> 5;
 248
 249         if (__builtin_constant_p(nr))
 250                 nr &= 0x1f;
 251
 252         bitops_lock(flags);
 253
 254         temp = *m;
 255         *m = temp ^ (1UL << nr);
 256
 257         bitops_unlock(flags);
 258 }
 259
 260 static inline int test_and_set_bit(unsigned long nr, volatile unsigned long *m)
 261 {
 262         unsigned long old, flags;
 263         m += nr >> 5;
 264
 265         if (__builtin_constant_p(nr))
 266                 nr &= 0x1f;
 267
 268         /*
 269          * spin lock/unlock provide the needed smp_mb() before/after
 270          */
 271         bitops_lock(flags);
 272
 273         old = *m;
 274         *m = old | (1 << nr);
 275
 276         bitops_unlock(flags);
 277
 278         return (old & (1 << nr)) != 0;
 279 }
 280
 281 static inline int
 282 test_and_clear_bit(unsigned long nr, volatile unsigned long *m)
 283 {
 284         unsigned long old, flags;
 285         m += nr >> 5;
 286
 287         if (__builtin_constant_p(nr))
 288                 nr &= 0x1f;
 289
 290         bitops_lock(flags);
 291
 292         old = *m;
 293         *m = old & ~(1 << nr);
 294
 295         bitops_unlock(flags);
 296
 297         return (old & (1 << nr)) != 0;
 298 }
 299
 300 static inline int
 301 test_and_change_bit(unsigned long nr, volatile unsigned long *m)
 302 {
 303         unsigned long old, flags;
 304         m += nr >> 5;
 305
 306         if (__builtin_constant_p(nr))
 307                 nr &= 0x1f;
 308
 309         bitops_lock(flags);
 310
 311         old = *m;
 312         *m = old ^ (1 << nr);
 313
 314         bitops_unlock(flags);
 315
 316         return (old & (1 << nr)) != 0;
 317 }
 318
 319 #endif /* CONFIG_ARC_HAS_LLSC */
 320
 321 /***************************************
 322  * Non atomic variants
 323  **************************************/
 324
 325 static inline void __set_bit(unsigned long nr, volatile unsigned long *m)
 326 {
 327         unsigned long temp;
 328         m += nr >> 5;
 329
 330         if (__builtin_constant_p(nr))
 331                 nr &= 0x1f;
 332
 333         temp = *m;
 334         *m = temp | (1UL << nr);
 335 }
 336
 337 static inline void __clear_bit(unsigned long nr, volatile unsigned long *m)
 338 {
 339         unsigned long temp;
 340         m += nr >> 5;
 341
 342         if (__builtin_constant_p(nr))
 343                 nr &= 0x1f;
 344
 345         temp = *m;
 346         *m = temp & ~(1UL << nr);
 347 }
 348
 349 static inline void __change_bit(unsigned long nr, volatile unsigned long *m)
 350 {
 351         unsigned long temp;
 352         m += nr >> 5;
 353
 354         if (__builtin_constant_p(nr))
 355                 nr &= 0x1f;
 356
 357         temp = *m;
 358         *m = temp ^ (1UL << nr);
 359 }
 360
 361 static inline int
 362 __test_and_set_bit(unsigned long nr, volatile unsigned long *m)
 363 {
 364         unsigned long old;
 365         m += nr >> 5;
 366
 367         if (__builtin_constant_p(nr))
 368                 nr &= 0x1f;
 369
 370         old = *m;
 371         *m = old | (1 << nr);
 372
 373         return (old & (1 << nr)) != 0;
 374 }
 375
 376 static inline int
 377 __test_and_clear_bit(unsigned long nr, volatile unsigned long *m)
 378 {
 379         unsigned long old;
 380         m += nr >> 5;
 381
 382         if (__builtin_constant_p(nr))
 383                 nr &= 0x1f;
 384
 385         old = *m;
 386         *m = old & ~(1 << nr);
 387
 388         return (old & (1 << nr)) != 0;
 389 }
 390
 391 static inline int
 392 __test_and_change_bit(unsigned long nr, volatile unsigned long *m)
 393 {
 394         unsigned long old;
 395         m += nr >> 5;
 396
 397         if (__builtin_constant_p(nr))
 398                 nr &= 0x1f;
 399
 400         old = *m;
 401         *m = old ^ (1 << nr);
 402
 403         return (old & (1 << nr)) != 0;
 404 }
 405
 406 /*
 407  * This routine doesn't need to be atomic.
 408  */
 409 static inline int
 410 test_bit(unsigned int nr, const volatile unsigned long *addr)
 411 {
 412         unsigned long mask;
 413
 414         addr += nr >> 5;
 415
 416         if (__builtin_constant_p(nr))
 417                 nr &= 0x1f;
 418
 419         mask = 1 << nr;
 420
 421         return ((mask & *addr) != 0);
 422 }
 423
 424 /*
 425  * Count the number of zeros, starting from MSB
 426  * Helper for fls( ) friends
 427  * This is a pure count, so (1-32) or (0-31) doesn't apply
 428  * It could be 0 to 32, based on num of 0's in there
 429  * clz(0x8000_0000) = 0, clz(0xFFFF_FFFF)=0, clz(0) = 32, clz(1) = 31
 430  */
 431 static inline __attribute__ ((const)) int clz(unsigned int x)
 432 {
 433         unsigned int res;
 434
 435         __asm__ __volatile__(
 436         "       norm.f  %0, %1          \n"
 437         "       mov.n   %0, 0           \n"
 438         "       add.p   %0, %0, 1       \n"
 439         : "=r"(res)
 440         : "r"(x)
 441         : "cc");
 442
 443         return res;
 444 }
 445
 446 static inline int constant_fls(int x)
 447 {
 448         int r = 32;
 449
 450         if (!x)
 451                 return 0;
 452         if (!(x & 0xffff0000u)) {
 453                 x <<= 16;
 454                 r -= 16;
 455         }
 456         if (!(x & 0xff000000u)) {
 457                 x <<= 8;
 458                 r -= 8;
 459         }
 460         if (!(x & 0xf0000000u)) {
 461                 x <<= 4;
 462                 r -= 4;
 463         }
 464         if (!(x & 0xc0000000u)) {
 465                 x <<= 2;
 466                 r -= 2;
 467         }
 468         if (!(x & 0x80000000u)) {
 469                 x <<= 1;
 470                 r -= 1;
 471         }
 472         return r;
 473 }
 474
 475 /*
 476  * fls = Find Last Set in word
 477  * @result: [1-32]
 478  * fls(1) = 1, fls(0x80000000) = 32, fls(0) = 0
 479  */
 480 static inline __attribute__ ((const)) int fls(unsigned long x)
 481 {
 482         if (__builtin_constant_p(x))
 483                return constant_fls(x);
 484
 485         return 32 - clz(x);
 486 }
 487
 488 /*
 489  * __fls: Similar to fls, but zero based (0-31)
 490  */
 491 static inline __attribute__ ((const)) int __fls(unsigned long x)
 492 {
 493         if (!x)
 494                 return 0;
 495         else
 496                 return fls(x) - 1;
 497 }
 498
 499 /*
 500  * ffs = Find First Set in word (LSB to MSB)
 501  * @result: [1-32], 0 if all 0's
 502  */
 503 #define ffs(x)  ({ unsigned long __t = (x); fls(__t & -__t); })
 504
 505 /*
 506  * __ffs: Similar to ffs, but zero based (0-31)
 507  */
 508 static inline __attribute__ ((const)) int __ffs(unsigned long word)
 509 {
 510         if (!word)
 511                 return word;
 512
 513         return ffs(word) - 1;
 514 }
 515
 516 /*
 517  * ffz = Find First Zero in word.
 518  * @return:[0-31], 32 if all 1's
 519  */
 520 #define ffz(x)  __ffs(~(x))
 521
 522 #include <asm-generic/bitops/hweight.h>
 523 #include <asm-generic/bitops/fls64.h>
 524 #include <asm-generic/bitops/sched.h>
 525 #include <asm-generic/bitops/lock.h>
 526
 527 #include <asm-generic/bitops/find.h>
 528 #include <asm-generic/bitops/le.h>
 529 #include <asm-generic/bitops/ext2-atomic-setbit.h>
 530
 531 #endif /* !__ASSEMBLY__ */
 532
 533 #endif