LXR linux/arch/mips/include/asm/atomic.h

   1/*
   2 * Atomic operations that C can't guarantee us.  Useful for
   3 * resource counting etc..
   4 *
   5 * But use these as seldom as possible since they are much more slower
   6 * than regular operations.
   7 *
   8 * This file is subject to the terms and conditions of the GNU General Public
   9 * License.  See the file "COPYING" in the main directory of this archive
  10 * for more details.
  11 *
  12 * Copyright (C) 1996, 97, 99, 2000, 03, 04, 06 by Ralf Baechle
  13 */
  14#ifndef _ASM_ATOMIC_H
  15#define _ASM_ATOMIC_H
  16
  17#include <linux/irqflags.h>
  18#include <linux/types.h>
  19#include <asm/barrier.h>
  20#include <asm/cpu-features.h>
  21#include <asm/war.h>
  22#include <asm/system.h>
  23
  24#define ATOMIC_INIT(i)    { (i) }
  25
  26/*
  27 * atomic_read - read atomic variable
  28 * @v: pointer of type atomic_t
  29 *
  30 * Atomically reads the value of @v.
  31 */
  32#define atomic_read(v)          (*(volatile int *)&(v)->counter)
  33
  34/*
  35 * atomic_set - set atomic variable
  36 * @v: pointer of type atomic_t
  37 * @i: required value
  38 *
  39 * Atomically sets the value of @v to @i.
  40 */
  41#define atomic_set(v, i)                ((v)->counter = (i))
  42
  43/*
  44 * atomic_add - add integer to atomic variable
  45 * @i: integer value to add
  46 * @v: pointer of type atomic_t
  47 *
  48 * Atomically adds @i to @v.
  49 */
  50static __inline__ void atomic_add(int i, atomic_t * v)
  51{
  52        if (kernel_uses_llsc && R10000_LLSC_WAR) {
  53                int temp;
  54
  55                __asm__ __volatile__(
  56                "       .set    mips3                                   \n"
  57                "1:     ll      %0, %1          # atomic_add            \n"
  58                "       addu    %0, %2                                  \n"
  59                "       sc      %0, %1                                  \n"
  60                "       beqzl   %0, 1b                                  \n"
  61                "       .set    mips0                                   \n"
  62                : "=&r" (temp), "=m" (v->counter)
  63                : "Ir" (i), "m" (v->counter));
  64        } else if (kernel_uses_llsc) {
  65                int temp;
  66
  67                do {
  68                        __asm__ __volatile__(
  69                        "       .set    mips3                           \n"
  70                        "       ll      %0, %1          # atomic_add    \n"
  71                        "       addu    %0, %2                          \n"
  72                        "       sc      %0, %1                          \n"
  73                        "       .set    mips0                           \n"
  74                        : "=&r" (temp), "=m" (v->counter)
  75                        : "Ir" (i), "m" (v->counter));
  76                } while (unlikely(!temp));
  77        } else {
  78                unsigned long flags;
  79
  80                raw_local_irq_save(flags);
  81                v->counter += i;
  82                raw_local_irq_restore(flags);
  83        }
  84}
  85
  86/*
  87 * atomic_sub - subtract the atomic variable
  88 * @i: integer value to subtract
  89 * @v: pointer of type atomic_t
  90 *
  91 * Atomically subtracts @i from @v.
  92 */
  93static __inline__ void atomic_sub(int i, atomic_t * v)
  94{
  95        if (kernel_uses_llsc && R10000_LLSC_WAR) {
  96                int temp;
  97
  98                __asm__ __volatile__(
  99                "       .set    mips3                                   \n"
 100                "1:     ll      %0, %1          # atomic_sub            \n"
 101                "       subu    %0, %2                                  \n"
 102                "       sc      %0, %1                                  \n"
 103                "       beqzl   %0, 1b                                  \n"
 104                "       .set    mips0                                   \n"
 105                : "=&r" (temp), "=m" (v->counter)
 106                : "Ir" (i), "m" (v->counter));
 107        } else if (kernel_uses_llsc) {
 108                int temp;
 109
 110                do {
 111                        __asm__ __volatile__(
 112                        "       .set    mips3                           \n"
 113                        "       ll      %0, %1          # atomic_sub    \n"
 114                        "       subu    %0, %2                          \n"
 115                        "       sc      %0, %1                          \n"
 116                        "       .set    mips0                           \n"
 117                        : "=&r" (temp), "=m" (v->counter)
 118                        : "Ir" (i), "m" (v->counter));
 119                } while (unlikely(!temp));
 120        } else {
 121                unsigned long flags;
 122
 123                raw_local_irq_save(flags);
 124                v->counter -= i;
 125                raw_local_irq_restore(flags);
 126        }
 127}
 128
 129/*
 130 * Same as above, but return the result value
 131 */
 132static __inline__ int atomic_add_return(int i, atomic_t * v)
 133{
 134        int result;
 135
 136        smp_mb__before_llsc();
 137
 138        if (kernel_uses_llsc && R10000_LLSC_WAR) {
 139                int temp;
 140
 141                __asm__ __volatile__(
 142                "       .set    mips3                                   \n"
 143                "1:     ll      %1, %2          # atomic_add_return     \n"
 144                "       addu    %0, %1, %3                              \n"
 145                "       sc      %0, %2                                  \n"
 146                "       beqzl   %0, 1b                                  \n"
 147                "       addu    %0, %1, %3                              \n"
 148                "       .set    mips0                                   \n"
 149                : "=&r" (result), "=&r" (temp), "=m" (v->counter)
 150                : "Ir" (i), "m" (v->counter)
 151                : "memory");
 152        } else if (kernel_uses_llsc) {
 153                int temp;
 154
 155                do {
 156                        __asm__ __volatile__(
 157                        "       .set    mips3                           \n"
 158                        "       ll      %1, %2  # atomic_add_return     \n"
 159                        "       addu    %0, %1, %3                      \n"
 160                        "       sc      %0, %2                          \n"
 161                        "       .set    mips0                           \n"
 162                        : "=&r" (result), "=&r" (temp), "=m" (v->counter)
 163                        : "Ir" (i), "m" (v->counter)
 164                        : "memory");
 165                } while (unlikely(!result));
 166
 167                result = temp + i;
 168        } else {
 169                unsigned long flags;
 170
 171                raw_local_irq_save(flags);
 172                result = v->counter;
 173                result += i;
 174                v->counter = result;
 175                raw_local_irq_restore(flags);
 176        }
 177
 178        smp_llsc_mb();
 179
 180        return result;
 181}
 182
 183static __inline__ int atomic_sub_return(int i, atomic_t * v)
 184{
 185        int result;
 186
 187        smp_mb__before_llsc();
 188
 189        if (kernel_uses_llsc && R10000_LLSC_WAR) {
 190                int temp;
 191
 192                __asm__ __volatile__(
 193                "       .set    mips3                                   \n"
 194                "1:     ll      %1, %2          # atomic_sub_return     \n"
 195                "       subu    %0, %1, %3                              \n"
 196                "       sc      %0, %2                                  \n"
 197                "       beqzl   %0, 1b                                  \n"
 198                "       subu    %0, %1, %3                              \n"
 199                "       .set    mips0                                   \n"
 200                : "=&r" (result), "=&r" (temp), "=m" (v->counter)
 201                : "Ir" (i), "m" (v->counter)
 202                : "memory");
 203
 204                result = temp - i;
 205        } else if (kernel_uses_llsc) {
 206                int temp;
 207
 208                do {
 209                        __asm__ __volatile__(
 210                        "       .set    mips3                           \n"
 211                        "       ll      %1, %2  # atomic_sub_return     \n"
 212                        "       subu    %0, %1, %3                      \n"
 213                        "       sc      %0, %2                          \n"
 214                        "       .set    mips0                           \n"
 215                        : "=&r" (result), "=&r" (temp), "=m" (v->counter)
 216                        : "Ir" (i), "m" (v->counter)
 217                        : "memory");
 218                } while (unlikely(!result));
 219
 220                result = temp - i;
 221        } else {
 222                unsigned long flags;
 223
 224                raw_local_irq_save(flags);
 225                result = v->counter;
 226                result -= i;
 227                v->counter = result;
 228                raw_local_irq_restore(flags);
 229        }
 230
 231        smp_llsc_mb();
 232
 233        return result;
 234}
 235
 236/*
 237 * atomic_sub_if_positive - conditionally subtract integer from atomic variable
 238 * @i: integer value to subtract
 239 * @v: pointer of type atomic_t
 240 *
 241 * Atomically test @v and subtract @i if @v is greater or equal than @i.
 242 * The function returns the old value of @v minus @i.
 243 */
 244static __inline__ int atomic_sub_if_positive(int i, atomic_t * v)
 245{
 246        int result;
 247
 248        smp_mb__before_llsc();
 249
 250        if (kernel_uses_llsc && R10000_LLSC_WAR) {
 251                int temp;
 252
 253                __asm__ __volatile__(
 254                "       .set    mips3                                   \n"
 255                "1:     ll      %1, %2          # atomic_sub_if_positive\n"
 256                "       subu    %0, %1, %3                              \n"
 257                "       bltz    %0, 1f                                  \n"
 258                "       sc      %0, %2                                  \n"
 259                "       .set    noreorder                               \n"
 260                "       beqzl   %0, 1b                                  \n"
 261                "        subu   %0, %1, %3                              \n"
 262                "       .set    reorder                                 \n"
 263                "1:                                                     \n"
 264                "       .set    mips0                                   \n"
 265                : "=&r" (result), "=&r" (temp), "=m" (v->counter)
 266                : "Ir" (i), "m" (v->counter)
 267                : "memory");
 268        } else if (kernel_uses_llsc) {
 269                int temp;
 270
 271                __asm__ __volatile__(
 272                "       .set    mips3                                   \n"
 273                "1:     ll      %1, %2          # atomic_sub_if_positive\n"
 274                "       subu    %0, %1, %3                              \n"
 275                "       bltz    %0, 1f                                  \n"
 276                "       sc      %0, %2                                  \n"
 277                "       .set    noreorder                               \n"
 278                "       beqz    %0, 1b                                  \n"
 279                "        subu   %0, %1, %3                              \n"
 280                "       .set    reorder                                 \n"
 281                "1:                                                     \n"
 282                "       .set    mips0                                   \n"
 283                : "=&r" (result), "=&r" (temp), "=m" (v->counter)
 284                : "Ir" (i), "m" (v->counter)
 285                : "memory");
 286        } else {
 287                unsigned long flags;
 288
 289                raw_local_irq_save(flags);
 290                result = v->counter;
 291                result -= i;
 292                if (result >= 0)
 293                        v->counter = result;
 294                raw_local_irq_restore(flags);
 295        }
 296
 297        smp_llsc_mb();
 298
 299        return result;
 300}
 301
 302#define atomic_cmpxchg(v, o, n) (cmpxchg(&((v)->counter), (o), (n)))
 303#define atomic_xchg(v, new) (xchg(&((v)->counter), (new)))
 304
 305/**
 306 * atomic_add_unless - add unless the number is a given value
 307 * @v: pointer of type atomic_t
 308 * @a: the amount to add to v...
 309 * @u: ...unless v is equal to u.
 310 *
 311 * Atomically adds @a to @v, so long as it was not @u.
 312 * Returns non-zero if @v was not @u, and zero otherwise.
 313 */
 314static __inline__ int atomic_add_unless(atomic_t *v, int a, int u)
 315{
 316        int c, old;
 317        c = atomic_read(v);
 318        for (;;) {
 319                if (unlikely(c == (u)))
 320                        break;
 321                old = atomic_cmpxchg((v), c, c + (a));
 322                if (likely(old == c))
 323                        break;
 324                c = old;
 325        }
 326        return c != (u);
 327}
 328#define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0)
 329
 330#define atomic_dec_return(v) atomic_sub_return(1, (v))
 331#define atomic_inc_return(v) atomic_add_return(1, (v))
 332
 333/*
 334 * atomic_sub_and_test - subtract value from variable and test result
 335 * @i: integer value to subtract
 336 * @v: pointer of type atomic_t
 337 *
 338 * Atomically subtracts @i from @v and returns
 339 * true if the result is zero, or false for all
 340 * other cases.
 341 */
 342#define atomic_sub_and_test(i, v) (atomic_sub_return((i), (v)) == 0)
 343
 344/*
 345 * atomic_inc_and_test - increment and test
 346 * @v: pointer of type atomic_t
 347 *
 348 * Atomically increments @v by 1
 349 * and returns true if the result is zero, or false for all
 350 * other cases.
 351 */
 352#define atomic_inc_and_test(v) (atomic_inc_return(v) == 0)
 353
 354/*
 355 * atomic_dec_and_test - decrement by 1 and test
 356 * @v: pointer of type atomic_t
 357 *
 358 * Atomically decrements @v by 1 and
 359 * returns true if the result is 0, or false for all other
 360 * cases.
 361 */
 362#define atomic_dec_and_test(v) (atomic_sub_return(1, (v)) == 0)
 363
 364/*
 365 * atomic_dec_if_positive - decrement by 1 if old value positive
 366 * @v: pointer of type atomic_t
 367 */
 368#define atomic_dec_if_positive(v)       atomic_sub_if_positive(1, v)
 369
 370/*
 371 * atomic_inc - increment atomic variable
 372 * @v: pointer of type atomic_t
 373 *
 374 * Atomically increments @v by 1.
 375 */
 376#define atomic_inc(v) atomic_add(1, (v))
 377
 378/*
 379 * atomic_dec - decrement and test
 380 * @v: pointer of type atomic_t
 381 *
 382 * Atomically decrements @v by 1.
 383 */
 384#define atomic_dec(v) atomic_sub(1, (v))
 385
 386/*
 387 * atomic_add_negative - add and test if negative
 388 * @v: pointer of type atomic_t
 389 * @i: integer value to add
 390 *
 391 * Atomically adds @i to @v and returns true
 392 * if the result is negative, or false when
 393 * result is greater than or equal to zero.
 394 */
 395#define atomic_add_negative(i, v) (atomic_add_return(i, (v)) < 0)
 396
 397#ifdef CONFIG_64BIT
 398
 399#define ATOMIC64_INIT(i)    { (i) }
 400
 401/*
 402 * atomic64_read - read atomic variable
 403 * @v: pointer of type atomic64_t
 404 *
 405 */
 406#define atomic64_read(v)        (*(volatile long *)&(v)->counter)
 407
 408/*
 409 * atomic64_set - set atomic variable
 410 * @v: pointer of type atomic64_t
 411 * @i: required value
 412 */
 413#define atomic64_set(v, i)      ((v)->counter = (i))
 414
 415/*
 416 * atomic64_add - add integer to atomic variable
 417 * @i: integer value to add
 418 * @v: pointer of type atomic64_t
 419 *
 420 * Atomically adds @i to @v.
 421 */
 422static __inline__ void atomic64_add(long i, atomic64_t * v)
 423{
 424        if (kernel_uses_llsc && R10000_LLSC_WAR) {
 425                long temp;
 426
 427                __asm__ __volatile__(
 428                "       .set    mips3                                   \n"
 429                "1:     lld     %0, %1          # atomic64_add          \n"
 430                "       daddu   %0, %2                                  \n"
 431                "       scd     %0, %1                                  \n"
 432                "       beqzl   %0, 1b                                  \n"
 433                "       .set    mips0                                   \n"
 434                : "=&r" (temp), "=m" (v->counter)
 435                : "Ir" (i), "m" (v->counter));
 436        } else if (kernel_uses_llsc) {
 437                long temp;
 438
 439                do {
 440                        __asm__ __volatile__(
 441                        "       .set    mips3                           \n"
 442                        "       lld     %0, %1          # atomic64_add  \n"
 443                        "       daddu   %0, %2                          \n"
 444                        "       scd     %0, %1                          \n"
 445                        "       .set    mips0                           \n"
 446                        : "=&r" (temp), "=m" (v->counter)
 447                        : "Ir" (i), "m" (v->counter));
 448                } while (unlikely(!temp));
 449        } else {
 450                unsigned long flags;
 451
 452                raw_local_irq_save(flags);
 453                v->counter += i;
 454                raw_local_irq_restore(flags);
 455        }
 456}
 457
 458/*
 459 * atomic64_sub - subtract the atomic variable
 460 * @i: integer value to subtract
 461 * @v: pointer of type atomic64_t
 462 *
 463 * Atomically subtracts @i from @v.
 464 */
 465static __inline__ void atomic64_sub(long i, atomic64_t * v)
 466{
 467        if (kernel_uses_llsc && R10000_LLSC_WAR) {
 468                long temp;
 469
 470                __asm__ __volatile__(
 471                "       .set    mips3                                   \n"
 472                "1:     lld     %0, %1          # atomic64_sub          \n"
 473                "       dsubu   %0, %2                                  \n"
 474                "       scd     %0, %1                                  \n"
 475                "       beqzl   %0, 1b                                  \n"
 476                "       .set    mips0                                   \n"
 477                : "=&r" (temp), "=m" (v->counter)
 478                : "Ir" (i), "m" (v->counter));
 479        } else if (kernel_uses_llsc) {
 480                long temp;
 481
 482                do {
 483                        __asm__ __volatile__(
 484                        "       .set    mips3                           \n"
 485                        "       lld     %0, %1          # atomic64_sub  \n"
 486                        "       dsubu   %0, %2                          \n"
 487                        "       scd     %0, %1                          \n"
 488                        "       .set    mips0                           \n"
 489                        : "=&r" (temp), "=m" (v->counter)
 490                        : "Ir" (i), "m" (v->counter));
 491                } while (unlikely(!temp));
 492        } else {
 493                unsigned long flags;
 494
 495                raw_local_irq_save(flags);
 496                v->counter -= i;
 497                raw_local_irq_restore(flags);
 498        }
 499}
 500
 501/*
 502 * Same as above, but return the result value
 503 */
 504static __inline__ long atomic64_add_return(long i, atomic64_t * v)
 505{
 506        long result;
 507
 508        smp_mb__before_llsc();
 509
 510        if (kernel_uses_llsc && R10000_LLSC_WAR) {
 511                long temp;
 512
 513                __asm__ __volatile__(
 514                "       .set    mips3                                   \n"
 515                "1:     lld     %1, %2          # atomic64_add_return   \n"
 516                "       daddu   %0, %1, %3                              \n"
 517                "       scd     %0, %2                                  \n"
 518                "       beqzl   %0, 1b                                  \n"
 519                "       daddu   %0, %1, %3                              \n"
 520                "       .set    mips0                                   \n"
 521                : "=&r" (result), "=&r" (temp), "=m" (v->counter)
 522                : "Ir" (i), "m" (v->counter)
 523                : "memory");
 524        } else if (kernel_uses_llsc) {
 525                long temp;
 526
 527                do {
 528                        __asm__ __volatile__(
 529                        "       .set    mips3                           \n"
 530                        "       lld     %1, %2  # atomic64_add_return   \n"
 531                        "       daddu   %0, %1, %3                      \n"
 532                        "       scd     %0, %2                          \n"
 533                        "       .set    mips0                           \n"
 534                        : "=&r" (result), "=&r" (temp), "=m" (v->counter)
 535                        : "Ir" (i), "m" (v->counter)
 536                        : "memory");
 537                } while (unlikely(!result));
 538
 539                result = temp + i;
 540        } else {
 541                unsigned long flags;
 542
 543                raw_local_irq_save(flags);
 544                result = v->counter;
 545                result += i;
 546                v->counter = result;
 547                raw_local_irq_restore(flags);
 548        }
 549
 550        smp_llsc_mb();
 551
 552        return result;
 553}
 554
 555static __inline__ long atomic64_sub_return(long i, atomic64_t * v)
 556{
 557        long result;
 558
 559        smp_mb__before_llsc();
 560
 561        if (kernel_uses_llsc && R10000_LLSC_WAR) {
 562                long temp;
 563
 564                __asm__ __volatile__(
 565                "       .set    mips3                                   \n"
 566                "1:     lld     %1, %2          # atomic64_sub_return   \n"
 567                "       dsubu   %0, %1, %3                              \n"
 568                "       scd     %0, %2                                  \n"
 569                "       beqzl   %0, 1b                                  \n"
 570                "       dsubu   %0, %1, %3                              \n"
 571                "       .set    mips0                                   \n"
 572                : "=&r" (result), "=&r" (temp), "=m" (v->counter)
 573                : "Ir" (i), "m" (v->counter)
 574                : "memory");
 575        } else if (kernel_uses_llsc) {
 576                long temp;
 577
 578                do {
 579                        __asm__ __volatile__(
 580                        "       .set    mips3                           \n"
 581                        "       lld     %1, %2  # atomic64_sub_return   \n"
 582                        "       dsubu   %0, %1, %3                      \n"
 583                        "       scd     %0, %2                          \n"
 584                        "       .set    mips0                           \n"
 585                        : "=&r" (result), "=&r" (temp), "=m" (v->counter)
 586                        : "Ir" (i), "m" (v->counter)
 587                        : "memory");
 588                } while (unlikely(!result));
 589
 590                result = temp - i;
 591        } else {
 592                unsigned long flags;
 593
 594                raw_local_irq_save(flags);
 595                result = v->counter;
 596                result -= i;
 597                v->counter = result;
 598                raw_local_irq_restore(flags);
 599        }
 600
 601        smp_llsc_mb();
 602
 603        return result;
 604}
 605
 606/*
 607 * atomic64_sub_if_positive - conditionally subtract integer from atomic variable
 608 * @i: integer value to subtract
 609 * @v: pointer of type atomic64_t
 610 *
 611 * Atomically test @v and subtract @i if @v is greater or equal than @i.
 612 * The function returns the old value of @v minus @i.
 613 */
 614static __inline__ long atomic64_sub_if_positive(long i, atomic64_t * v)
 615{
 616        long result;
 617
 618        smp_mb__before_llsc();
 619
 620        if (kernel_uses_llsc && R10000_LLSC_WAR) {
 621                long temp;
 622
 623                __asm__ __volatile__(
 624                "       .set    mips3                                   \n"
 625                "1:     lld     %1, %2          # atomic64_sub_if_positive\n"
 626                "       dsubu   %0, %1, %3                              \n"
 627                "       bltz    %0, 1f                                  \n"
 628                "       scd     %0, %2                                  \n"
 629                "       .set    noreorder                               \n"
 630                "       beqzl   %0, 1b                                  \n"
 631                "        dsubu  %0, %1, %3                              \n"
 632                "       .set    reorder                                 \n"
 633                "1:                                                     \n"
 634                "       .set    mips0                                   \n"
 635                : "=&r" (result), "=&r" (temp), "=m" (v->counter)
 636                : "Ir" (i), "m" (v->counter)
 637                : "memory");
 638        } else if (kernel_uses_llsc) {
 639                long temp;
 640
 641                __asm__ __volatile__(
 642                "       .set    mips3                                   \n"
 643                "1:     lld     %1, %2          # atomic64_sub_if_positive\n"
 644                "       dsubu   %0, %1, %3                              \n"
 645                "       bltz    %0, 1f                                  \n"
 646                "       scd     %0, %2                                  \n"
 647                "       .set    noreorder                               \n"
 648                "       beqz    %0, 1b                                  \n"
 649                "        dsubu  %0, %1, %3                              \n"
 650                "       .set    reorder                                 \n"
 651                "1:                                                     \n"
 652                "       .set    mips0                                   \n"
 653                : "=&r" (result), "=&r" (temp), "=m" (v->counter)
 654                : "Ir" (i), "m" (v->counter)
 655                : "memory");
 656        } else {
 657                unsigned long flags;
 658
 659                raw_local_irq_save(flags);
 660                result = v->counter;
 661                result -= i;
 662                if (result >= 0)
 663                        v->counter = result;
 664                raw_local_irq_restore(flags);
 665        }
 666
 667        smp_llsc_mb();
 668
 669        return result;
 670}
 671
 672#define atomic64_cmpxchg(v, o, n) \
 673        ((__typeof__((v)->counter))cmpxchg(&((v)->counter), (o), (n)))
 674#define atomic64_xchg(v, new) (xchg(&((v)->counter), (new)))
 675
 676/**
 677 * atomic64_add_unless - add unless the number is a given value
 678 * @v: pointer of type atomic64_t
 679 * @a: the amount to add to v...
 680 * @u: ...unless v is equal to u.
 681 *
 682 * Atomically adds @a to @v, so long as it was not @u.
 683 * Returns non-zero if @v was not @u, and zero otherwise.
 684 */
 685static __inline__ int atomic64_add_unless(atomic64_t *v, long a, long u)
 686{
 687        long c, old;
 688        c = atomic64_read(v);
 689        for (;;) {
 690                if (unlikely(c == (u)))
 691                        break;
 692                old = atomic64_cmpxchg((v), c, c + (a));
 693                if (likely(old == c))
 694                        break;
 695                c = old;
 696        }
 697        return c != (u);
 698}
 699
 700#define atomic64_inc_not_zero(v) atomic64_add_unless((v), 1, 0)
 701
 702#define atomic64_dec_return(v) atomic64_sub_return(1, (v))
 703#define atomic64_inc_return(v) atomic64_add_return(1, (v))
 704
 705/*
 706 * atomic64_sub_and_test - subtract value from variable and test result
 707 * @i: integer value to subtract
 708 * @v: pointer of type atomic64_t
 709 *
 710 * Atomically subtracts @i from @v and returns
 711 * true if the result is zero, or false for all
 712 * other cases.
 713 */
 714#define atomic64_sub_and_test(i, v) (atomic64_sub_return((i), (v)) == 0)
 715
 716/*
 717 * atomic64_inc_and_test - increment and test
 718 * @v: pointer of type atomic64_t
 719 *
 720 * Atomically increments @v by 1
 721 * and returns true if the result is zero, or false for all
 722 * other cases.
 723 */
 724#define atomic64_inc_and_test(v) (atomic64_inc_return(v) == 0)
 725
 726/*
 727 * atomic64_dec_and_test - decrement by 1 and test
 728 * @v: pointer of type atomic64_t
 729 *
 730 * Atomically decrements @v by 1 and
 731 * returns true if the result is 0, or false for all other
 732 * cases.
 733 */
 734#define atomic64_dec_and_test(v) (atomic64_sub_return(1, (v)) == 0)
 735
 736/*
 737 * atomic64_dec_if_positive - decrement by 1 if old value positive
 738 * @v: pointer of type atomic64_t
 739 */
 740#define atomic64_dec_if_positive(v)     atomic64_sub_if_positive(1, v)
 741
 742/*
 743 * atomic64_inc - increment atomic variable
 744 * @v: pointer of type atomic64_t
 745 *
 746 * Atomically increments @v by 1.
 747 */
 748#define atomic64_inc(v) atomic64_add(1, (v))
 749
 750/*
 751 * atomic64_dec - decrement and test
 752 * @v: pointer of type atomic64_t
 753 *
 754 * Atomically decrements @v by 1.
 755 */
 756#define atomic64_dec(v) atomic64_sub(1, (v))
 757
 758/*
 759 * atomic64_add_negative - add and test if negative
 760 * @v: pointer of type atomic64_t
 761 * @i: integer value to add
 762 *
 763 * Atomically adds @i to @v and returns true
 764 * if the result is negative, or false when
 765 * result is greater than or equal to zero.
 766 */
 767#define atomic64_add_negative(i, v) (atomic64_add_return(i, (v)) < 0)
 768
 769#else /* !CONFIG_64BIT */
 770
 771#include <asm-generic/atomic64.h>
 772
 773#endif /* CONFIG_64BIT */
 774
 775/*
 776 * atomic*_return operations are serializing but not the non-*_return
 777 * versions.
 778 */
 779#define smp_mb__before_atomic_dec()     smp_mb__before_llsc()
 780#define smp_mb__after_atomic_dec()      smp_llsc_mb()
 781#define smp_mb__before_atomic_inc()     smp_mb__before_llsc()
 782#define smp_mb__after_atomic_inc()      smp_llsc_mb()
 783
 784#include <asm-generic/atomic-long.h>
 785
 786#endif /* _ASM_ATOMIC_H */
 787