minixfs: kill manual hweight(), simplify

#include <linux/bitops.h>

#include <linux/sched.h>

static const int nibblemap[] = { 4,3,3,2,3,2,2,1,3,2,2,1,2,1,1,0 };

static DEFINE_SPINLOCK(bitmap_lock);

static unsigned long count_free(struct buffer_head *map[], unsigned blocksize, __u32 numbits)

/*

 * bitmap consists of blocks filled with 16bit words

 * bit set == busy, bit clear == free

 * endianness is a mess, but for counting zero bits it really doesn't matter...

 */

static __u32 count_free(struct buffer_head *map[], unsigned blocksize, __u32 numbits)

{

	unsigned i, j, sum = 0;

	struct buffer_head *bh;

	unsigned numblocks = minix_blocks_needed(numbits, blocksize);

	__u32 sum = 0;

	unsigned blocks = DIV_ROUND_UP(numbits, blocksize * 8);

	for (i=0; i<numblocks-1; i++) {

		if (!(bh=map[i])) 

			return(0);

		for (j=0; j<bh->b_size; j++)

			sum += nibblemap[bh->b_data[j] & 0xf]

				+ nibblemap[(bh->b_data[j]>>4) & 0xf];

	while (blocks--) {

		unsigned words = blocksize / 2;

		__u16 *p = (__u16 *)(*map++)->b_data;

		while (words--)

			sum += 16 - hweight16(*p++);

	}

	if (numblocks==0 || !(bh=map[numblocks-1]))

		return(0);

	i = ((numbits - (numblocks-1) * bh->b_size * 8) / 16) * 2;

	for (j=0; j<i; j++) {

		sum += nibblemap[bh->b_data[j] & 0xf]

			+ nibblemap[(bh->b_data[j]>>4) & 0xf];

	}

	i = numbits%16;

	if (i!=0) {

		i = *(__u16 *)(&bh->b_data[j]) | ~((1<<i) - 1);

		sum += nibblemap[i & 0xf] + nibblemap[(i>>4) & 0xf];

		sum += nibblemap[(i>>8) & 0xf] + nibblemap[(i>>12) & 0xf];

	}

	return(sum);

	return sum;

}

void minix_free_block(struct inode *inode, unsigned long block)

	if (!size)

		return 0;

	size = (size >> 4) + ((size & 15) > 0);

	size >>= 4;

	while (*p++ == 0xffff) {

		if (--size == 0)

			return (p - addr) << 4;