Merge branch 'kbuild' of git://git.kernel.org/pub/scm/linux/kernel/git/mmarek/kbuild (0ca7ffb3) · Commits · e / devices / android_kernel_samsung_universal8895

Makefile

+3 −3

Original line number	Original line	Diff line number	Diff line
	@@ -192,7 +192,6 @@ SUBARCH := $(shell uname -m \| sed -e s/i.86/x86/ -e s/x86_64/x86/ \
	# "make" in the configured kernel build directory always uses that.		# "make" in the configured kernel build directory always uses that.
	# Default value for CROSS_COMPILE is not to prefix executables		# Default value for CROSS_COMPILE is not to prefix executables
	# Note: Some architectures assign CROSS_COMPILE in their arch/*/Makefile		# Note: Some architectures assign CROSS_COMPILE in their arch/*/Makefile
	export KBUILD_BUILDHOST := $(SUBARCH)
	ARCH ?= $(SUBARCH)		ARCH ?= $(SUBARCH)
	CROSS_COMPILE ?= $(CONFIG_CROSS_COMPILE:"%"=%)		CROSS_COMPILE ?= $(CONFIG_CROSS_COMPILE:"%"=%)

	@@ -620,7 +619,8 @@ KBUILD_AFLAGS += -gdwarf-2
	endif		endif

	ifdef CONFIG_DEBUG_INFO_REDUCED		ifdef CONFIG_DEBUG_INFO_REDUCED
	KBUILD_CFLAGS += $(call cc-option, -femit-struct-debug-baseonly)		KBUILD_CFLAGS += $(call cc-option, -femit-struct-debug-baseonly) \
			$(call cc-option,-fno-var-tracking)
	endif		endif

	ifdef CONFIG_FUNCTION_TRACER		ifdef CONFIG_FUNCTION_TRACER
	@@ -1398,7 +1398,7 @@ quiet_cmd_rmfiles = $(if $(wildcard $(rm-files)),CLEAN $(wildcard $(rm-files))
	# Run depmod only if we have System.map and depmod is executable		# Run depmod only if we have System.map and depmod is executable
	quiet_cmd_depmod = DEPMOD $(KERNELRELEASE)		quiet_cmd_depmod = DEPMOD $(KERNELRELEASE)
	cmd_depmod = $(CONFIG_SHELL) $(srctree)/scripts/depmod.sh $(DEPMOD) \		cmd_depmod = $(CONFIG_SHELL) $(srctree)/scripts/depmod.sh $(DEPMOD) \
	$(KERNELRELEASE)		$(KERNELRELEASE) "$(patsubst "%",%,$(CONFIG_SYMBOL_PREFIX))"

	# Create temporary dir for module support files		# Create temporary dir for module support files
	# clean it up only when building all modules		# clean it up only when building all modules

include/linux/mod_devicetable.h

+9 −49

Original line number	Original line	Diff line number	Diff line
	@@ -33,8 +33,7 @@ struct ieee1394_device_id {
	__u32 model_id;		__u32 model_id;
	__u32 specifier_id;		__u32 specifier_id;
	__u32 version;		__u32 version;
	kernel_ulong_t driver_data		kernel_ulong_t driver_data;
	__attribute__((aligned(sizeof(kernel_ulong_t))));
	};		};


	@@ -148,8 +147,7 @@ struct hid_device_id {
	__u16 group;		__u16 group;
	__u32 vendor;		__u32 vendor;
	__u32 product;		__u32 product;
	kernel_ulong_t driver_data		kernel_ulong_t driver_data;
	__attribute__((aligned(sizeof(kernel_ulong_t))));
	};		};

	/* s390 CCW devices */		/* s390 CCW devices */
	@@ -173,8 +171,6 @@ struct ccw_device_id {
	struct ap_device_id {		struct ap_device_id {
	__u16 match_flags; /* which fields to match against */		__u16 match_flags; /* which fields to match against */
	__u8 dev_type; /* device type */		__u8 dev_type; /* device type */
	__u8 pad1;
	__u32 pad2;
	kernel_ulong_t driver_info;		kernel_ulong_t driver_info;
	};		};

	@@ -184,13 +180,10 @@ struct ap_device_id {
	struct css_device_id {		struct css_device_id {
	__u8 match_flags;		__u8 match_flags;
	__u8 type; /* subchannel type */		__u8 type; /* subchannel type */
	__u16 pad2;
	__u32 pad3;
	kernel_ulong_t driver_data;		kernel_ulong_t driver_data;
	};		};

	#define ACPI_ID_LEN 16 /* only 9 bytes needed here, 16 bytes are used */		#define ACPI_ID_LEN 9
	/* to workaround crosscompile issues */

	struct acpi_device_id {		struct acpi_device_id {
	__u8 id[ACPI_ID_LEN];		__u8 id[ACPI_ID_LEN];
	@@ -231,11 +224,7 @@ struct of_device_id
	char name[32];		char name[32];
	char type[32];		char type[32];
	char compatible[128];		char compatible[128];
	#ifdef __KERNEL__
	const void *data;		const void *data;
	#else
	kernel_ulong_t data;
	#endif
	};		};

	/* VIO */		/* VIO */
	@@ -260,24 +249,14 @@ struct pcmcia_device_id {
	/* for pseudo multi-function devices */		/* for pseudo multi-function devices */
	__u8 device_no;		__u8 device_no;

	__u32 prod_id_hash[4]		__u32 prod_id_hash[4];
	__attribute__((aligned(sizeof(__u32))));

	/* not matched against in kernelspace*/		/* not matched against in kernelspace*/
	#ifdef __KERNEL__
	const char * prod_id[4];		const char * prod_id[4];
	#else
	kernel_ulong_t prod_id[4]
	__attribute__((aligned(sizeof(kernel_ulong_t))));
	#endif

	/* not matched against */		/* not matched against */
	kernel_ulong_t driver_info;		kernel_ulong_t driver_info;
	#ifdef __KERNEL__
	char * cisfile;		char * cisfile;
	#else
	kernel_ulong_t cisfile;
	#endif
	};		};

	#define PCMCIA_DEV_ID_MATCH_MANF_ID 0x0001		#define PCMCIA_DEV_ID_MATCH_MANF_ID 0x0001
	@@ -373,8 +352,7 @@ struct sdio_device_id {
	__u8 class; /* Standard interface or SDIO_ANY_ID */		__u8 class; /* Standard interface or SDIO_ANY_ID */
	__u16 vendor; /* Vendor or SDIO_ANY_ID */		__u16 vendor; /* Vendor or SDIO_ANY_ID */
	__u16 device; /* Device ID or SDIO_ANY_ID */		__u16 device; /* Device ID or SDIO_ANY_ID */
	kernel_ulong_t driver_data /* Data private to the driver */		kernel_ulong_t driver_data; /* Data private to the driver */
	__attribute__((aligned(sizeof(kernel_ulong_t))));
	};		};

	/* SSB core, see drivers/ssb/ */		/* SSB core, see drivers/ssb/ */
	@@ -420,8 +398,7 @@ struct virtio_device_id {
	*/		*/
	struct hv_vmbus_device_id {		struct hv_vmbus_device_id {
	__u8 guid[16];		__u8 guid[16];
	kernel_ulong_t driver_data /* Data private to the driver */		kernel_ulong_t driver_data; /* Data private to the driver */
	__attribute__((aligned(sizeof(kernel_ulong_t))));
	};		};

	/* rpmsg */		/* rpmsg */
	@@ -440,8 +417,7 @@ struct rpmsg_device_id {

	struct i2c_device_id {		struct i2c_device_id {
	char name[I2C_NAME_SIZE];		char name[I2C_NAME_SIZE];
	kernel_ulong_t driver_data /* Data private to the driver */		kernel_ulong_t driver_data; /* Data private to the driver */
	__attribute__((aligned(sizeof(kernel_ulong_t))));
	};		};

	/* spi */		/* spi */
	@@ -451,8 +427,7 @@ struct i2c_device_id {

	struct spi_device_id {		struct spi_device_id {
	char name[SPI_NAME_SIZE];		char name[SPI_NAME_SIZE];
	kernel_ulong_t driver_data /* Data private to the driver */		kernel_ulong_t driver_data; /* Data private to the driver */
	__attribute__((aligned(sizeof(kernel_ulong_t))));
	};		};

	/* dmi */		/* dmi */
	@@ -484,15 +459,6 @@ struct dmi_strmatch {
	char substr[79];		char substr[79];
	};		};

	#ifndef __KERNEL__
	struct dmi_system_id {
	kernel_ulong_t callback;
	kernel_ulong_t ident;
	struct dmi_strmatch matches[4];
	kernel_ulong_t driver_data
	__attribute__((aligned(sizeof(kernel_ulong_t))));
	};
	#else
	struct dmi_system_id {		struct dmi_system_id {
	int (callback)(const struct dmi_system_id );		int (callback)(const struct dmi_system_id );
	const char *ident;		const char *ident;
	@@ -506,7 +472,6 @@ struct dmi_system_id {
	* error: storage size of '__mod_dmi_device_table' isn't known		* error: storage size of '__mod_dmi_device_table' isn't known
	*/		*/
	#define dmi_device_id dmi_system_id		#define dmi_device_id dmi_system_id
	#endif

	#define DMI_MATCH(a, b) { a, b }		#define DMI_MATCH(a, b) { a, b }

	@@ -515,8 +480,7 @@ struct dmi_system_id {

	struct platform_device_id {		struct platform_device_id {
	char name[PLATFORM_NAME_SIZE];		char name[PLATFORM_NAME_SIZE];
	kernel_ulong_t driver_data		kernel_ulong_t driver_data;
	__attribute__((aligned(sizeof(kernel_ulong_t))));
	};		};

	#define MDIO_MODULE_PREFIX "mdio:"		#define MDIO_MODULE_PREFIX "mdio:"
	@@ -572,11 +536,7 @@ struct isapnp_device_id {
	struct amba_id {		struct amba_id {
	unsigned int id;		unsigned int id;
	unsigned int mask;		unsigned int mask;
	#ifndef __KERNEL__
	kernel_ulong_t data;
	#else
	void *data;		void *data;
	#endif
	};		};

	/*		/*

kernel/Makefile

+12 −4

Original line number	Original line	Diff line number	Diff line
	@@ -127,11 +127,19 @@ $(obj)/config_data.h: $(obj)/config_data.gz FORCE

	$(obj)/time.o: $(obj)/timeconst.h		$(obj)/time.o: $(obj)/timeconst.h

	quiet_cmd_timeconst = TIMEC $@		quiet_cmd_hzfile = HZFILE $@
	cmd_timeconst = $(PERL) $< $(CONFIG_HZ) > $@		cmd_hzfile = echo "hz=$(CONFIG_HZ)" > $@

			targets += hz.bc
			$(obj)/hz.bc: $(objtree)/include/config/hz.h FORCE
			$(call if_changed,hzfile)

			quiet_cmd_bc = BC $@
			cmd_bc = bc -q $(filter-out FORCE,$^) > $@

	targets += timeconst.h		targets += timeconst.h
	$(obj)/timeconst.h: $(src)/timeconst.pl FORCE		$(obj)/timeconst.h: $(obj)/hz.bc $(src)/timeconst.bc FORCE
	$(call if_changed,timeconst)		$(call if_changed,bc)

	ifeq ($(CONFIG_MODULE_SIG),y)		ifeq ($(CONFIG_MODULE_SIG),y)
	#		#

kernel/timeconst.bc

0 → 100644

+108 −0

Original line number	Original line	Diff line number	Diff line
			scale=0

			define gcd(a,b) {
			auto t;
			while (b) {
			t = b;
			b = a % b;
			a = t;
			}
			return a;
			}

			/* Division by reciprocal multiplication. */
			define fmul(b,n,d) {
			return (2^b*n+d-1)/d;
			}

			/* Adjustment factor when a ceiling value is used. Use as:
			(imul * n) + (fmulxx * n + fadjxx) >> xx) */
			define fadj(b,n,d) {
			auto v;
			d = d/gcd(n,d);
			v = 2^b*(d-1)/d;
			return v;
			}

			/* Compute the appropriate mul/adj values as well as a shift count,
			which brings the mul value into the range 2^b-1 <= x < 2^b. Such
			a shift value will be correct in the signed integer range and off
			by at most one in the upper half of the unsigned range. */
			define fmuls(b,n,d) {
			auto s, m;
			for (s = 0; 1; s++) {
			m = fmul(s,n,d);
			if (m >= 2^(b-1))
			return s;
			}
			return 0;
			}

			define timeconst(hz) {
			print "/* Automatically generated by kernel/timeconst.bc */\n"
			print "/* Time conversion constants for HZ == ", hz, " */\n"
			print "\n"

			print "#ifndef KERNEL_TIMECONST_H\n"
			print "#define KERNEL_TIMECONST_H\n\n"

			print "#include <linux/param.h>\n"
			print "#include <linux/types.h>\n\n"

			print "#if HZ != ", hz, "\n"
			print "#error \qkernel/timeconst.h has the wrong HZ value!\q\n"
			print "#endif\n\n"

			if (hz < 2) {
			print "#error Totally bogus HZ value!\n"
			} else {
			s=fmuls(32,1000,hz)
			obase=16
			print "#define HZ_TO_MSEC_MUL32\tU64_C(0x", fmul(s,1000,hz), ")\n"
			print "#define HZ_TO_MSEC_ADJ32\tU64_C(0x", fadj(s,1000,hz), ")\n"
			obase=10
			print "#define HZ_TO_MSEC_SHR32\t", s, "\n"

			s=fmuls(32,hz,1000)
			obase=16
			print "#define MSEC_TO_HZ_MUL32\tU64_C(0x", fmul(s,hz,1000), ")\n"
			print "#define MSEC_TO_HZ_ADJ32\tU64_C(0x", fadj(s,hz,1000), ")\n"
			obase=10
			print "#define MSEC_TO_HZ_SHR32\t", s, "\n"

			obase=10
			cd=gcd(hz,1000)
			print "#define HZ_TO_MSEC_NUM\t\t", 1000/cd, "\n"
			print "#define HZ_TO_MSEC_DEN\t\t", hz/cd, "\n"
			print "#define MSEC_TO_HZ_NUM\t\t", hz/cd, "\n"
			print "#define MSEC_TO_HZ_DEN\t\t", 1000/cd, "\n"
			print "\n"

			s=fmuls(32,1000000,hz)
			obase=16
			print "#define HZ_TO_USEC_MUL32\tU64_C(0x", fmul(s,1000000,hz), ")\n"
			print "#define HZ_TO_USEC_ADJ32\tU64_C(0x", fadj(s,1000000,hz), ")\n"
			obase=10
			print "#define HZ_TO_USEC_SHR32\t", s, "\n"

			s=fmuls(32,hz,1000000)
			obase=16
			print "#define USEC_TO_HZ_MUL32\tU64_C(0x", fmul(s,hz,1000000), ")\n"
			print "#define USEC_TO_HZ_ADJ32\tU64_C(0x", fadj(s,hz,1000000), ")\n"
			obase=10
			print "#define USEC_TO_HZ_SHR32\t", s, "\n"

			obase=10
			cd=gcd(hz,1000000)
			print "#define HZ_TO_USEC_NUM\t\t", 1000000/cd, "\n"
			print "#define HZ_TO_USEC_DEN\t\t", hz/cd, "\n"
			print "#define USEC_TO_HZ_NUM\t\t", hz/cd, "\n"
			print "#define USEC_TO_HZ_DEN\t\t", 1000000/cd, "\n"
			print "\n"

			print "#endif /* KERNEL_TIMECONST_H */\n"
			}
			halt
			}

			timeconst(hz)

kernel/timeconst.pl

deleted100644 → 0

+0 −376

Original line number	Original line	Diff line number	Diff line
	#!/usr/bin/perl
	# -----------------------------------------------------------------------
	#
	# Copyright 2007-2008 rPath, Inc. - All Rights Reserved
	#
	# This file is part of the Linux kernel, and is made available under
	# the terms of the GNU General Public License version 2 or (at your
	# option) any later version; incorporated herein by reference.
	#
	# -----------------------------------------------------------------------
	#

	#
	# Usage: timeconst.pl HZ > timeconst.h
	#

	# Precomputed values for systems without Math::BigInt
	# Generated by:
	# timeconst.pl --can 24 32 48 64 100 122 128 200 250 256 300 512 1000 1024 1200
	%canned_values = (
	24 => [
	'0xa6aaaaab','0x2aaaaaa',26,
	125,3,
	'0xc49ba5e4','0x1fbe76c8b4',37,
	3,125,
	'0xa2c2aaab','0xaaaa',16,
	125000,3,
	'0xc9539b89','0x7fffbce4217d',47,
	3,125000,
	], 32 => [
	'0xfa000000','0x6000000',27,
	125,4,
	'0x83126e98','0xfdf3b645a',36,
	4,125,
	'0xf4240000','0x0',17,
	31250,1,
	'0x8637bd06','0x3fff79c842fa',46,
	1,31250,
	], 48 => [
	'0xa6aaaaab','0x6aaaaaa',27,
	125,6,
	'0xc49ba5e4','0xfdf3b645a',36,
	6,125,
	'0xa2c2aaab','0x15555',17,
	62500,3,
	'0xc9539b89','0x3fffbce4217d',46,
	3,62500,
	], 64 => [
	'0xfa000000','0xe000000',28,
	125,8,
	'0x83126e98','0x7ef9db22d',35,
	8,125,
	'0xf4240000','0x0',18,
	15625,1,
	'0x8637bd06','0x1fff79c842fa',45,
	1,15625,
	], 100 => [
	'0xa0000000','0x0',28,
	10,1,
	'0xcccccccd','0x733333333',35,
	1,10,
	'0x9c400000','0x0',18,
	10000,1,
	'0xd1b71759','0x1fff2e48e8a7',45,
	1,10000,
	], 122 => [
	'0x8325c53f','0xfbcda3a',28,
	500,61,
	'0xf9db22d1','0x7fbe76c8b',35,
	61,500,
	'0x8012e2a0','0x3ef36',18,
	500000,61,
	'0xffda4053','0x1ffffbce4217',45,
	61,500000,
	], 128 => [
	'0xfa000000','0x1e000000',29,
	125,16,
	'0x83126e98','0x3f7ced916',34,
	16,125,
	'0xf4240000','0x40000',19,
	15625,2,
	'0x8637bd06','0xfffbce4217d',44,
	2,15625,
	], 200 => [
	'0xa0000000','0x0',29,
	5,1,
	'0xcccccccd','0x333333333',34,
	1,5,
	'0x9c400000','0x0',19,
	5000,1,
	'0xd1b71759','0xfff2e48e8a7',44,
	1,5000,
	], 250 => [
	'0x80000000','0x0',29,
	4,1,
	'0x80000000','0x180000000',33,
	1,4,
	'0xfa000000','0x0',20,
	4000,1,
	'0x83126e98','0x7ff7ced9168',43,
	1,4000,
	], 256 => [
	'0xfa000000','0x3e000000',30,
	125,32,
	'0x83126e98','0x1fbe76c8b',33,
	32,125,
	'0xf4240000','0xc0000',20,
	15625,4,
	'0x8637bd06','0x7ffde7210be',43,
	4,15625,
	], 300 => [
	'0xd5555556','0x2aaaaaaa',30,
	10,3,
	'0x9999999a','0x1cccccccc',33,
	3,10,
	'0xd0555556','0xaaaaa',20,
	10000,3,
	'0x9d495183','0x7ffcb923a29',43,
	3,10000,
	], 512 => [
	'0xfa000000','0x7e000000',31,
	125,64,
	'0x83126e98','0xfdf3b645',32,
	64,125,
	'0xf4240000','0x1c0000',21,
	15625,8,
	'0x8637bd06','0x3ffef39085f',42,
	8,15625,
	], 1000 => [
	'0x80000000','0x0',31,
	1,1,
	'0x80000000','0x0',31,
	1,1,
	'0xfa000000','0x0',22,
	1000,1,
	'0x83126e98','0x1ff7ced9168',41,
	1,1000,
	], 1024 => [
	'0xfa000000','0xfe000000',32,
	125,128,
	'0x83126e98','0x7ef9db22',31,
	128,125,
	'0xf4240000','0x3c0000',22,
	15625,16,
	'0x8637bd06','0x1fff79c842f',41,
	16,15625,
	], 1200 => [
	'0xd5555556','0xd5555555',32,
	5,6,
	'0x9999999a','0x66666666',31,
	6,5,
	'0xd0555556','0x2aaaaa',22,
	2500,3,
	'0x9d495183','0x1ffcb923a29',41,
	3,2500,
	]
	);

	$has_bigint = eval 'use Math::BigInt qw(bgcd); 1;';

	sub bint($)
	{
	my($x) = @_;
	return Math::BigInt->new($x);
	}

	#
	# Constants for division by reciprocal multiplication.
	# (bits, numerator, denominator)
	#
	sub fmul($$$)
	{
	my ($b,$n,$d) = @_;

	$n = bint($n);
	$d = bint($d);

	return scalar (($n << $b)+$d-bint(1))/$d;
	}

	sub fadj($$$)
	{
	my($b,$n,$d) = @_;

	$n = bint($n);
	$d = bint($d);

	$d = $d/bgcd($n, $d);
	return scalar (($d-bint(1)) << $b)/$d;
	}

	sub fmuls($$$) {
	my($b,$n,$d) = @_;
	my($s,$m);
	my($thres) = bint(1) << ($b-1);

	$n = bint($n);
	$d = bint($d);

	for ($s = 0; 1; $s++) {
	$m = fmul($s,$n,$d);
	return $s if ($m >= $thres);
	}
	return 0;
	}

	# Generate a hex value if the result fits in 64 bits;
	# otherwise skip.
	sub bignum_hex($) {
	my($x) = @_;
	my $s = $x->as_hex();

	return (length($s) > 18) ? undef : $s;
	}

	# Provides mul, adj, and shr factors for a specific
	# (bit, time, hz) combination
	sub muladj($$$) {
	my($b, $t, $hz) = @_;
	my $s = fmuls($b, $t, $hz);
	my $m = fmul($s, $t, $hz);
	my $a = fadj($s, $t, $hz);
	return (bignum_hex($m), bignum_hex($a), $s);
	}

	# Provides numerator, denominator values
	sub numden($$) {
	my($n, $d) = @_;
	my $g = bgcd($n, $d);
	return ($n/$g, $d/$g);
	}

	# All values for a specific (time, hz) combo
	sub conversions($$) {
	my ($t, $hz) = @_;
	my @val = ();

	# HZ_TO_xx
	push(@val, muladj(32, $t, $hz));
	push(@val, numden($t, $hz));

	# xx_TO_HZ
	push(@val, muladj(32, $hz, $t));
	push(@val, numden($hz, $t));

	return @val;
	}

	sub compute_values($) {
	my($hz) = @_;
	my @val = ();
	my $s, $m, $a, $g;

	if (!$has_bigint) {
	die "$0: HZ == $hz not canned and ".
	"Math::BigInt not available\n";
	}

	# MSEC conversions
	push(@val, conversions(1000, $hz));

	# USEC conversions
	push(@val, conversions(1000000, $hz));

	return @val;
	}

	sub outputval($$)
	{
	my($name, $val) = @_;
	my $csuf;

	if (defined($val)) {
	if ($name !~ /SHR/) {
	$val = "U64_C($val)";
	}
	printf "#define %-23s %s\n", $name.$csuf, $val.$csuf;
	}
	}

	sub output($@)
	{
	my($hz, @val) = @_;
	my $pfx, $bit, $suf, $s, $m, $a;

	print "/* Automatically generated by kernel/timeconst.pl */\n";
	print "/* Conversion constants for HZ == $hz */\n";
	print "\n";
	print "#ifndef KERNEL_TIMECONST_H\n";
	print "#define KERNEL_TIMECONST_H\n";
	print "\n";

	print "#include <linux/param.h>\n";
	print "#include <linux/types.h>\n";

	print "\n";
	print "#if HZ != $hz\n";
	print "#error \"kernel/timeconst.h has the wrong HZ value!\"\n";
	print "#endif\n";
	print "\n";

	foreach $pfx ('HZ_TO_MSEC','MSEC_TO_HZ',
	'HZ_TO_USEC','USEC_TO_HZ') {
	foreach $bit (32) {
	foreach $suf ('MUL', 'ADJ', 'SHR') {
	outputval("${pfx}_$suf$bit", shift(@val));
	}
	}
	foreach $suf ('NUM', 'DEN') {
	outputval("${pfx}_$suf", shift(@val));
	}
	}

	print "\n";
	print "#endif /* KERNEL_TIMECONST_H */\n";
	}

	# Pretty-print Perl values
	sub perlvals(@) {
	my $v;
	my @l = ();

	foreach $v (@_) {
	if (!defined($v)) {
	push(@l, 'undef');
	} elsif ($v =~ /^0x/) {
	push(@l, "\'".$v."\'");
	} else {
	push(@l, $v.'');
	}
	}
	return join(',', @l);
	}

	($hz) = @ARGV;

	# Use this to generate the %canned_values structure
	if ($hz eq '--can') {
	shift(@ARGV);
	@hzlist = sort {$a <=> $b} (@ARGV);

	print "# Precomputed values for systems without Math::BigInt\n";
	print "# Generated by:\n";
	print "# timeconst.pl --can ", join(' ', @hzlist), "\n";
	print "\%canned_values = (\n";
	my $pf = "\t";
	foreach $hz (@hzlist) {
	my @values = compute_values($hz);
	print "$pf$hz => [\n";
	while (scalar(@values)) {
	my $bit;
	foreach $bit (32) {
	my $m = shift(@values);
	my $a = shift(@values);
	my $s = shift(@values);
	print "\t\t", perlvals($m,$a,$s), ",\n";
	}
	my $n = shift(@values);
	my $d = shift(@values);
	print "\t\t", perlvals($n,$d), ",\n";
	}
	print "\t]";
	$pf = ', ';
	}
	print "\n);\n";
	} else {
	$hz += 0; # Force to number
	if ($hz < 1) {
	die "Usage: $0 HZ\n";
	}

	$cv = $canned_values{$hz};
	@val = defined($cv) ? @$cv : compute_values($hz);
	output($hz, @val);
	}
	exit 0;