Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0734e00e authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'parisc-4.17-1' of git://git.kernel.org/pub/scm/linux/kernel/git/deller/parisc-linux 

Pull parisc updates from Helge Deller:
 "Lots of small enhancements and fixes in this patchset:

   - improved the x86-64 compatibility for PCI cards by returning -1UL
     for timed out MMIO transactions (instead of crashing)

   - fixed HPMC handler for PAT machines: size needs to be multiple of 16

   - prepare machine_power_off() to be able to turn rp3410 and c8000
     machines off via IMPI

   - added code to extract machine info for usage with qemu

   - some init sections fixes

   - lots of fixes for sparse-, ubsan- and uninitalized variables
     warnings"

* 'parisc-4.17-1' of git://git.kernel.org/pub/scm/linux/kernel/git/deller/parisc-linux:
  parisc: Fix out of array access in match_pci_device()
  parisc: Add code generator for Qemu/SeaBIOS machine info
  parisc/pci: Switch LBA PCI bus from Hard Fail to Soft Fail mode
  parisc: Fix HPMC handler by increasing size to multiple of 16 bytes
  parisc: Directly call machine_power_off() in power button driver
  parisc: machine_power_off() should call pm_power_off()
  parisc/Kconfig: SMP kernels boot on all machines
  parisc: Silence uninitialized variable warning in dbl_to_sgl_fcnvff()
  parisc: Move various functions and strings to init section
  parisc: Convert MAP_TYPE to cover 4 bits on parisc
  parisc: Force to various endian types for sparse
  parisc/gscps2: Fix sparse warnings
  parisc/led: Fix sparse warnings
  parisc/parport_gsc: Use NULL to avoid sparse warning
  parisc/stifb: Use fb_memset() to avoid sparse warning
parents 4608f064 615b2665

arch/parisc/Kconfig

+2 −4
Original line number Diff line number Diff line
@@ -276,10 +276,8 @@ config SMP 
	  than one CPU, say Y.



	  If you say N here, the kernel will run on uni- and multiprocessor

	  machines, but will use only one CPU of a multiprocessor machine. If

	  you say Y here, the kernel will run on many, but not all,

	  uniprocessor machines. On a uniprocessor machine, the kernel

	  will run faster if you say N here.

	  machines, but will use only one CPU of a multiprocessor machine.

	  On a uniprocessor machine, the kernel will run faster if you say N.



	  See also <file:Documentation/nmi_watchdog.txt> and the SMP-HOWTO

	  available at <http://www.tldp.org/docs.html#howto>.

arch/parisc/include/asm/io.h

+6 −6
Original line number Diff line number Diff line
@@ -183,15 +183,15 @@ static inline unsigned char readb(const volatile void __iomem *addr) 
}

static inline unsigned short readw(const volatile void __iomem *addr)

{

	return le16_to_cpu(__raw_readw(addr));

	return le16_to_cpu((__le16 __force) __raw_readw(addr));

}

static inline unsigned int readl(const volatile void __iomem *addr)

{

	return le32_to_cpu(__raw_readl(addr));

	return le32_to_cpu((__le32 __force) __raw_readl(addr));

}

static inline unsigned long long readq(const volatile void __iomem *addr)

{

	return le64_to_cpu(__raw_readq(addr));

	return le64_to_cpu((__le64 __force) __raw_readq(addr));

}



static inline void writeb(unsigned char b, volatile void __iomem *addr)
@@ -200,15 +200,15 @@ static inline void writeb(unsigned char b, volatile void __iomem *addr) 
}

static inline void writew(unsigned short w, volatile void __iomem *addr)

{

	__raw_writew(cpu_to_le16(w), addr);

	__raw_writew((__u16 __force) cpu_to_le16(w), addr);

}

static inline void writel(unsigned int l, volatile void __iomem *addr)

{

	__raw_writel(cpu_to_le32(l), addr);

	__raw_writel((__u32 __force) cpu_to_le32(l), addr);

}

static inline void writeq(unsigned long long q, volatile void __iomem *addr)

{

	__raw_writeq(cpu_to_le64(q), addr);

	__raw_writeq((__u64 __force) cpu_to_le64(q), addr);

}



#define	readb	readb

arch/parisc/include/uapi/asm/mman.h

+1 −1
Original line number Diff line number Diff line
@@ -13,7 +13,7 @@ 
#define MAP_SHARED	0x01		/* Share changes */

#define MAP_PRIVATE	0x02		/* Changes are private */

#define MAP_SHARED_VALIDATE 0x03	/* share + validate extension flags */

#define MAP_TYPE	0x03		/* Mask for type of mapping */

#define MAP_TYPE	0x2b		/* Mask for type of mapping, includes bits 0x08 and 0x20 */

#define MAP_FIXED	0x04		/* Interpret addr exactly */

#define MAP_ANONYMOUS	0x10		/* don't use a file */

arch/parisc/kernel/drivers.c

+186 −11
Original line number Diff line number Diff line
@@ -135,7 +135,7 @@ static int parisc_driver_probe(struct device *dev) 
	return rc;

}



static int parisc_driver_remove(struct device *dev)

static int __exit parisc_driver_remove(struct device *dev)

{

	struct parisc_device *pa_dev = to_parisc_device(dev);

	struct parisc_driver *pa_drv = to_parisc_driver(dev->driver);
@@ -205,7 +205,7 @@ static int match_and_count(struct device * dev, void * data) 
 * Use by IOMMU support to "guess" the right size IOPdir.

 * Formula is something like memsize/(num_iommu * entry_size).

 */

int count_parisc_driver(struct parisc_driver *driver)

int __init count_parisc_driver(struct parisc_driver *driver)

{

	struct match_count m = {

		.driver	= driver,
@@ -268,7 +268,7 @@ static struct parisc_device *find_device_by_addr(unsigned long hpa) 
 * Walks up the device tree looking for a device of the specified type.

 * If it finds it, it returns it.  If not, it returns NULL.

 */

const struct parisc_device *

const struct parisc_device * __init

find_pa_parent_type(const struct parisc_device *padev, int type)

{

	const struct device *dev = &padev->dev;
@@ -397,7 +397,7 @@ static void setup_bus_id(struct parisc_device *padev) 
	dev_set_name(&padev->dev, name);

}



struct parisc_device * create_tree_node(char id, struct device *parent)

struct parisc_device * __init create_tree_node(char id, struct device *parent)

{

	struct parisc_device *dev = kzalloc(sizeof(*dev), GFP_KERNEL);

	if (!dev)
@@ -471,7 +471,7 @@ static struct parisc_device *create_parisc_device(struct hardware_path *modpath) 
	return alloc_tree_node(parent, modpath->mod);

}



struct parisc_device *

struct parisc_device * __init

alloc_pa_dev(unsigned long hpa, struct hardware_path *mod_path)

{

	int status;
@@ -609,7 +609,7 @@ struct bus_type parisc_bus_type = { 
	.uevent = parisc_uevent,

	.dev_groups = parisc_device_groups,

	.probe = parisc_driver_probe,

	.remove = parisc_driver_remove,

	.remove = __exit_p(parisc_driver_remove),

};



/**
@@ -619,7 +619,7 @@ struct bus_type parisc_bus_type = { 
 * Search the driver list for a driver that is willing to manage

 * this device.

 */

int register_parisc_device(struct parisc_device *dev)

int __init register_parisc_device(struct parisc_device *dev)

{

	if (!dev)

		return 0;
@@ -651,6 +651,10 @@ static int match_pci_device(struct device *dev, int index, 
					(modpath->mod == PCI_FUNC(devfn)));

	}



	/* index might be out of bounds for bc[] */

	if (index >= 6)

		return 0;



	id = PCI_SLOT(pdev->devfn) | (PCI_FUNC(pdev->devfn) << 5);

	return (modpath->bc[index] == id);

}
@@ -791,7 +795,7 @@ EXPORT_SYMBOL(device_to_hwpath); 
static void walk_native_bus(unsigned long io_io_low, unsigned long io_io_high,

                            struct device *parent);



void walk_lower_bus(struct parisc_device *dev)

static void walk_lower_bus(struct parisc_device *dev)

{

	unsigned long io_io_low, io_io_high;
@@ -857,7 +861,7 @@ static void walk_native_bus(unsigned long io_io_low, unsigned long io_io_high, 
 * PDC doesn't tell us about all devices in the system.  This routine

 * finds devices connected to the central bus.

 */

void walk_central_bus(void)

void __init walk_central_bus(void)

{

	walk_native_bus(CENTRAL_BUS_ADDR,

			CENTRAL_BUS_ADDR + (MAX_NATIVE_DEVICES * NATIVE_DEVICE_OFFSET),
@@ -886,7 +890,7 @@ static void print_parisc_device(struct parisc_device *dev) 
/**

 * init_parisc_bus - Some preparation to be done before inventory

 */

void init_parisc_bus(void)

void __init init_parisc_bus(void)

{

	if (bus_register(&parisc_bus_type))

		panic("Could not register PA-RISC bus type\n");
@@ -895,6 +899,171 @@ void init_parisc_bus(void) 
	get_device(&root);

}



static __init void qemu_header(void)

{

	int num;

	unsigned long *p;



	pr_info("--- cut here ---\n");

	pr_info("/* AUTO-GENERATED HEADER FILE FOR SEABIOS FIRMWARE */\n");

	pr_cont("/* generated with Linux kernel */\n");

	pr_cont("/* search for PARISC_QEMU_MACHINE_HEADER in Linux */\n\n");



	pr_info("#define PARISC_MODEL \"%s\"\n\n",

			boot_cpu_data.pdc.sys_model_name);



	pr_info("#define PARISC_PDC_MODEL 0x%lx, 0x%lx, 0x%lx, "

		"0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx\n\n",

	#define p ((unsigned long *)&boot_cpu_data.pdc.model)

		p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8]);

	#undef p



	pr_info("#define PARISC_PDC_VERSION 0x%04lx\n\n",

			boot_cpu_data.pdc.versions);



	pr_info("#define PARISC_PDC_CPUID 0x%04lx\n\n",

			boot_cpu_data.pdc.cpuid);



	pr_info("#define PARISC_PDC_CAPABILITIES 0x%04lx\n\n",

			boot_cpu_data.pdc.capabilities);



	pr_info("#define PARISC_PDC_ENTRY_ORG 0x%04lx\n\n",

#ifdef CONFIG_64BIT

		(unsigned long)(PAGE0->mem_pdc_hi) << 32 |

#endif

		(unsigned long)PAGE0->mem_pdc);



	pr_info("#define PARISC_PDC_CACHE_INFO");

	p = (unsigned long *) &cache_info;

	for (num = 0; num < sizeof(cache_info); num += sizeof(unsigned long)) {

		if (((num % 5) == 0)) {

			pr_cont(" \\\n");

			pr_info("\t");

		}

		pr_cont("%s0x%04lx",

			num?", ":"", *p++);

	}

	pr_cont("\n\n");

}



static __init int qemu_print_hpa(struct device *lin_dev, void *data)

{

	struct parisc_device *dev = to_parisc_device(lin_dev);

	unsigned long hpa = dev->hpa.start;



	pr_cont("\t{\t.hpa = 0x%08lx,\\\n", hpa);

	pr_cont("\t\t.iodc = &iodc_data_hpa_%08lx,\\\n", hpa);

	pr_cont("\t\t.mod_info = &mod_info_hpa_%08lx,\\\n", hpa);

	pr_cont("\t\t.mod_path = &mod_path_hpa_%08lx,\\\n", hpa);

	pr_cont("\t\t.num_addr = HPA_%08lx_num_addr,\\\n", hpa);

	pr_cont("\t\t.add_addr = { HPA_%08lx_add_addr } },\\\n", hpa);

	return 0;

}





static __init void qemu_footer(void)

{

	pr_info("\n\n#define PARISC_DEVICE_LIST \\\n");

	for_each_padev(qemu_print_hpa, NULL);

	pr_cont("\t{ 0, }\n");

	pr_info("--- cut here ---\n");

}



/* print iodc data of the various hpa modules for qemu inclusion */

static __init int qemu_print_iodc_data(struct device *lin_dev, void *data)

{

	struct parisc_device *dev = to_parisc_device(lin_dev);

	unsigned long count;

	unsigned long hpa = dev->hpa.start;

	int status;

	struct pdc_iodc iodc_data;



	int mod_index;

	struct pdc_system_map_mod_info pdc_mod_info;

	struct pdc_module_path mod_path;



	status = pdc_iodc_read(&count, hpa, 0,

		&iodc_data, sizeof(iodc_data));

	if (status != PDC_OK) {

		pr_info("No IODC data for hpa 0x%08lx\n", hpa);

		return 0;

	}



	pr_info("\n");



	pr_info("#define HPA_%08lx_DESCRIPTION \"%s\"\n",

		hpa, parisc_hardware_description(&dev->id));



	mod_index = 0;

	do {

		status = pdc_system_map_find_mods(&pdc_mod_info,

				&mod_path, mod_index++);

	} while (status == PDC_OK && pdc_mod_info.mod_addr != hpa);



	pr_info("static struct pdc_system_map_mod_info"

		" mod_info_hpa_%08lx = {\n", hpa);

	#define DO(member) \

		pr_cont("\t." #member " = 0x%x,\n", \

			(unsigned int)pdc_mod_info.member)

	DO(mod_addr);

	DO(mod_pgs);

	DO(add_addrs);

	pr_cont("};\n");

	#undef DO

	pr_info("static struct pdc_module_path "

		"mod_path_hpa_%08lx = {\n", hpa);

	pr_cont("\t.path = { ");

	pr_cont(".flags = 0x%x, ", mod_path.path.flags);

	pr_cont(".bc = { 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x }, ",

		(unsigned char)mod_path.path.bc[0],

		(unsigned char)mod_path.path.bc[1],

		(unsigned char)mod_path.path.bc[2],

		(unsigned char)mod_path.path.bc[3],

		(unsigned char)mod_path.path.bc[4],

		(unsigned char)mod_path.path.bc[5]);

	pr_cont(".mod = 0x%x ", mod_path.path.mod);

	pr_cont(" },\n");

	pr_cont("\t.layers = { 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x }\n",

		mod_path.layers[0], mod_path.layers[1], mod_path.layers[2],

		mod_path.layers[3], mod_path.layers[4], mod_path.layers[5]);

	pr_cont("};\n");



	pr_info("static struct pdc_iodc iodc_data_hpa_%08lx = {\n", hpa);

	#define DO(member) \

		pr_cont("\t." #member " = 0x%04lx,\n", \

			(unsigned long)iodc_data.member)

	DO(hversion_model);

	DO(hversion);

	DO(spa);

	DO(type);

	DO(sversion_rev);

	DO(sversion_model);

	DO(sversion_opt);

	DO(rev);

	DO(dep);

	DO(features);

	DO(checksum);

	DO(length);

	#undef DO

	pr_cont("\t/* pad: 0x%04x, 0x%04x */\n",

		iodc_data.pad[0], iodc_data.pad[1]);

	pr_cont("};\n");



	pr_info("#define HPA_%08lx_num_addr %d\n", hpa, dev->num_addrs);

	pr_info("#define HPA_%08lx_add_addr ", hpa);

	count = 0;

	if (dev->num_addrs == 0)

		pr_cont("0");

	while (count < dev->num_addrs) {

		pr_cont("0x%08lx, ", dev->addr[count]);

		count++;

	}

	pr_cont("\n\n");



	return 0;

}







static int print_one_device(struct device * dev, void * data)

{
@@ -908,7 +1077,13 @@ static int print_one_device(struct device * dev, void * data) 
/**

 * print_parisc_devices - Print out a list of devices found in this system

 */

void print_parisc_devices(void)

void __init print_parisc_devices(void)

{

	for_each_padev(print_one_device, NULL);

	#define PARISC_QEMU_MACHINE_HEADER 0

	if (PARISC_QEMU_MACHINE_HEADER) {

		qemu_header();

		for_each_padev(qemu_print_iodc_data, NULL);

		qemu_footer();

	}

}

arch/parisc/kernel/hardware.c

+6 −6
Original line number Diff line number Diff line
@@ -41,7 +41,7 @@ 
 *	are guessed. If you know the correct name, please let us know.

 */

 

static struct hp_hardware hp_hardware_list[] = {

static struct hp_hardware hp_hardware_list[] __initdata = {

	{HPHW_NPROC,0x01,0x4,0x0,"Indigo (840, 930)"},

	{HPHW_NPROC,0x8,0x4,0x01,"Firefox(825,925)"},

	{HPHW_NPROC,0xA,0x4,0x01,"Top Gun (835,834,935,635)"},
@@ -1238,7 +1238,7 @@ static struct hp_cpu_type_mask { 
	unsigned short model;

	unsigned short mask;

	enum cpu_type cpu;

} hp_cpu_type_mask_list[] = {

} hp_cpu_type_mask_list[] __initdata = {



	{ 0x0000, 0x0ff0, pcx    },  /* 0x0000 - 0x000f */

	{ 0x0048, 0x0ff0, pcxl   },  /* 0x0040 - 0x004f */
@@ -1335,7 +1335,7 @@ const char * const cpu_name_version[][2] = { 
	[mako2] = { "PA8900 (Shortfin)","2.0" }

};



const char *parisc_hardware_description(struct parisc_device_id *id)

const char * __init parisc_hardware_description(struct parisc_device_id *id)

{

	struct hp_hardware *listptr;
@@ -1373,7 +1373,7 @@ const char *parisc_hardware_description(struct parisc_device_id *id) 




/* Interpret hversion (ret[0]) from PDC_MODEL(4)/PDC_MODEL_INFO(0) */

enum cpu_type

enum cpu_type __init

parisc_get_cpu_type(unsigned long hversion)

{

	struct hp_cpu_type_mask *ptr;