← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to arch/s390/include/asm/bitops.h

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
arch/s390/include/asm/bitops.h
621
621
        bits = __ffz_word(bytes*8, __load_ulong_be(addr, bytes));
622
622
        return (bits < size) ? bits : size;
623
623
}
 
624
#define find_first_zero_bit find_first_zero_bit
624
625
 
625
626
/**
626
627
 * find_first_bit - find the first set bit in a memory region
641
642
        bits = __ffs_word(bytes*8, __load_ulong_be(addr, bytes));
642
643
        return (bits < size) ? bits : size;
643
644
}
 
645
#define find_first_bit find_first_bit
644
646
 
645
647
/**
646
648
 * find_next_zero_bit - find the first zero bit in a memory region
677
679
        }
678
680
        return offset + find_first_zero_bit(p, size);
679
681
}
 
682
#define find_next_zero_bit find_next_zero_bit
680
683
 
681
684
/**
682
685
 * find_next_bit - find the first set bit in a memory region
713
716
        }
714
717
        return offset + find_first_bit(p, size);
715
718
}
 
719
#define find_next_bit find_next_bit
716
720
 
717
721
/*
718
722
 * Every architecture must define this function. It's the fastest
742
746
 *    23 22 21 20 19 18 17 16 31 30 29 28 27 26 25 24
743
747
 */
744
748
 
745
 
#define ext2_set_bit(nr, addr)       \
746
 
        __test_and_set_bit((nr)^(__BITOPS_WORDSIZE - 8), (unsigned long *)addr)
747
 
#define ext2_set_bit_atomic(lock, nr, addr)       \
748
 
        test_and_set_bit((nr)^(__BITOPS_WORDSIZE - 8), (unsigned long *)addr)
749
 
#define ext2_clear_bit(nr, addr)     \
750
 
        __test_and_clear_bit((nr)^(__BITOPS_WORDSIZE - 8), (unsigned long *)addr)
751
 
#define ext2_clear_bit_atomic(lock, nr, addr)     \
752
 
        test_and_clear_bit((nr)^(__BITOPS_WORDSIZE - 8), (unsigned long *)addr)
753
 
#define ext2_test_bit(nr, addr)      \
754
 
        test_bit((nr)^(__BITOPS_WORDSIZE - 8), (unsigned long *)addr)
755
 
 
756
 
static inline int ext2_find_first_zero_bit(void *vaddr, unsigned int size)
 
749
static inline int find_first_zero_bit_le(void *vaddr, unsigned int size)
757
750
{
758
751
        unsigned long bytes, bits;
759
752
 
763
756
        bits = __ffz_word(bytes*8, __load_ulong_le(vaddr, bytes));
764
757
        return (bits < size) ? bits : size;
765
758
}
 
759
#define find_first_zero_bit_le find_first_zero_bit_le
766
760
 
767
 
static inline int ext2_find_next_zero_bit(void *vaddr, unsigned long size,
 
761
static inline int find_next_zero_bit_le(void *vaddr, unsigned long size,
768
762
                                          unsigned long offset)
769
763
{
770
764
        unsigned long *addr = vaddr, *p;
790
784
                size -= __BITOPS_WORDSIZE;
791
785
                p++;
792
786
        }
793
 
        return offset + ext2_find_first_zero_bit(p, size);
 
787
        return offset + find_first_zero_bit_le(p, size);
794
788
}
 
789
#define find_next_zero_bit_le find_next_zero_bit_le
795
790
 
796
 
static inline unsigned long ext2_find_first_bit(void *vaddr,
797
 
                                                unsigned long size)
 
791
static inline unsigned long find_first_bit_le(void *vaddr, unsigned long size)
798
792
{
799
793
        unsigned long bytes, bits;
800
794
 
804
798
        bits = __ffs_word(bytes*8, __load_ulong_le(vaddr, bytes));
805
799
        return (bits < size) ? bits : size;
806
800
}
 
801
#define find_first_bit_le find_first_bit_le
807
802
 
808
 
static inline int ext2_find_next_bit(void *vaddr, unsigned long size,
 
803
static inline int find_next_bit_le(void *vaddr, unsigned long size,
809
804
                                     unsigned long offset)
810
805
{
811
806
        unsigned long *addr = vaddr, *p;
831
826
                size -= __BITOPS_WORDSIZE;
832
827
                p++;
833
828
        }
834
 
        return offset + ext2_find_first_bit(p, size);
 
829
        return offset + find_first_bit_le(p, size);
835
830
}
836
 
 
837
 
#include <asm-generic/bitops/minix.h>
 
831
#define find_next_bit_le find_next_bit_le
 
832
 
 
833
#include <asm-generic/bitops/le.h>
 
834
 
 
835
#define ext2_set_bit_atomic(lock, nr, addr)     \
 
836
        test_and_set_bit_le(nr, addr)
 
837
#define ext2_clear_bit_atomic(lock, nr, addr)   \
 
838
        test_and_clear_bit_le(nr, addr)
 
839
 
838
840
 
839
841
#endif /* __KERNEL__ */
840
842