partially fix aarch64 BE on the zero2w

drivers/clk/bcm/clk-raspberrypi.c

@@ -198,6 +198,8 @@ static int raspberrypi_fw_is_prepared(struct clk_hw *hw)
 	if (ret)
 		return 0;
 
+        val = le32_to_cpu(val);
+
 	return !!(val & RPI_FIRMWARE_STATE_ENABLE_BIT);
 }
 
@@ -215,6 +217,8 @@ static unsigned long raspberrypi_fw_get_rate(struct clk_hw *hw,
 	if (ret)
 		return 0;
 
+        val = le32_to_cpu(val);
+
 	return val;
 }
 
@@ -310,6 +314,9 @@ static struct clk_hw *raspberrypi_clk_register(struct raspberrypi_clk *rpi,
 		return ERR_PTR(ret);
 	}
 
+        min_rate = le32_to_cpu(min_rate);
+        max_rate = le32_to_cpu(max_rate);
+
 	ret = devm_clk_hw_register(rpi->dev, &data->hw);
 	if (ret)
 		return ERR_PTR(ret);
@@ -370,6 +377,9 @@ static int raspberrypi_discover_clocks(struct raspberrypi_clk *rpi,
 		return ret;
 
 	while (clks->id) {
+                clks->id = le32_to_cpu(clks->id);
+                clks->parent = le32_to_cpu(clks->parent);
+
 		struct raspberrypi_clk_variant *variant;
 
 		if (clks->id >= RPI_FIRMWARE_NUM_CLK_ID) {

drivers/firmware/raspberrypi.c

@@ -109,24 +109,27 @@ int rpi_firmware_property_list(struct rpi_firmware *fw,
 	/* The firmware will error out without parsing in this case. */
 	WARN_ON(size >= 1024 * 1024);
 
-	buf[0] = size;
-	buf[1] = RPI_FIRMWARE_STATUS_REQUEST;
+	buf[0] = cpu_to_le32(size);
+	buf[1] = cpu_to_le32(RPI_FIRMWARE_STATUS_REQUEST);
 	memcpy(&buf[2], data, tag_size);
-	buf[size / 4 - 1] = RPI_FIRMWARE_PROPERTY_END;
+	buf[size / 4 - 1] = cpu_to_le32(RPI_FIRMWARE_PROPERTY_END);
+
+        //for (int i=0; i < (size/4); i++) printk(" 0x%x ", buf[i]);
+
 	wmb();
 
 	ret = rpi_firmware_transaction(fw, MBOX_CHAN_PROPERTY, bus_addr);
 
 	rmb();
 	memcpy(data, &buf[2], tag_size);
-	if (ret == 0 && buf[1] != RPI_FIRMWARE_STATUS_SUCCESS) {
+	if (ret == 0 && le32_to_cpu(buf[1]) != RPI_FIRMWARE_STATUS_SUCCESS) {
 		/*
 		 * The tag name here might not be the one causing the
 		 * error, if there were multiple tags in the request.
 		 * But single-tag is the most common, so go with it.
 		 */
 		dev_err(fw->cl.dev, "Request 0x%08x returned status 0x%08x\n",
-			buf[2], buf[1]);
+			le32_to_cpu(buf[2]), le32_to_cpu(buf[1]));
 		ret = -EINVAL;
 	}
 
@@ -167,8 +170,8 @@ int rpi_firmware_property(struct rpi_firmware *fw,
 		return -ENOMEM;
 
 	header = data;
-	header->tag = tag;
-	header->buf_size = buf_size;
+	header->tag = cpu_to_le32(tag);
+	header->buf_size = cpu_to_le32(buf_size);
 	header->req_resp_size = 0;
 	memcpy(data + sizeof(*header), tag_data, buf_size);
 
@@ -272,10 +275,11 @@ rpi_firmware_print_firmware_revision(struct rpi_firmware *fw)
 		return;
 
 	/* This is not compatible with y2038 */
-	date_and_time = packet;
+	date_and_time = le32_to_cpu(packet);
 
 	ret = rpi_firmware_property(fw, RPI_FIRMWARE_GET_FIRMWARE_VARIANT,
 				    &variant, sizeof(variant));
+        variant = le32_to_cpu(variant);
 
 	if (!ret) {
 		if (variant >= ARRAY_SIZE(variant_strs))
@@ -299,6 +303,8 @@ rpi_firmware_print_firmware_hash(struct rpi_firmware *fw)
 	if (ret)
 		return;
 
+        for (int i=0; i<5; i++) hash[i] = le32_to_cpu(hash[i]);
+
 	dev_info(fw->cl.dev,
 		 "Firmware hash is %08x%08x%08x%08x%08x\n",
 		 hash[0], hash[1], hash[2], hash[3], hash[4]);

drivers/hwmon/raspberrypi-hwmon.c

@@ -31,7 +31,7 @@ static void rpi_firmware_get_throttled(struct rpi_hwmon_data *data)
 	int ret;
 
 	/* Request firmware to clear sticky bits */
-	value = 0xffff;
+	value = cpu_to_le32(0xffff);
 
 	ret = rpi_firmware_property(data->fw, RPI_FIRMWARE_GET_THROTTLED,
 				    &value, sizeof(value));
@@ -40,6 +40,7 @@ static void rpi_firmware_get_throttled(struct rpi_hwmon_data *data)
 			     ret);
 		return;
 	}
+        value = le32_to_cpu(value);
 
 	new_uv = value & UNDERVOLTAGE_STICKY_BIT;
 	old_uv = data->last_throttled & UNDERVOLTAGE_STICKY_BIT;

drivers/mmc/host/bcm2835-sdhost.c

@@ -1568,13 +1568,13 @@ void bcm2835_sdhost_set_clock(struct bcm2835_host *host, unsigned int clock)
 	host->mmc->actual_clock = 0;
 
 	if (host->firmware_sets_cdiv) {
-		u32 msg[3] = { clock, 0, 0 };
+		u32 msg[3] = { cpu_to_le32(clock), 0, 0 };
 
 		rpi_firmware_property(host->fw,
 				      RPI_FIRMWARE_SET_SDHOST_CLOCK,
 				      &msg, sizeof(msg));
 
-		clock = max(msg[1], msg[2]);
+		clock = max(le32_to_cpu(msg[1]), le32_to_cpu(msg[2]));
 		spin_lock_irqsave(&host->lock, flags);
 	} else {
 		spin_lock_irqsave(&host->lock, flags);
@@ -2142,14 +2142,14 @@ static int bcm2835_sdhost_probe(struct platform_device *pdev)
 		mmc->caps |= MMC_CAP_4_BIT_DATA;
 
 	msg[0] = 0;
-	msg[1] = ~0;
-	msg[2] = ~0;
+	msg[1] = cpu_to_le32(~0);
+	msg[2] = cpu_to_le32(~0);
 
 	rpi_firmware_property(host->fw,
 			      RPI_FIRMWARE_SET_SDHOST_CLOCK,
 			      &msg, sizeof(msg));
 
-	host->firmware_sets_cdiv = (msg[1] != ~0);
+	host->firmware_sets_cdiv = (le32_to_cpu(msg[1]) != ~0);
 
 	platform_set_drvdata(pdev, host);
 

drivers/pmdomain/bcm/raspberrypi-power.c

@@ -141,14 +141,14 @@ rpi_has_new_domain_support(struct rpi_power_domains *rpi_domains)
 	struct rpi_power_domain_packet packet;
 	int ret;
 
-	packet.domain = RPI_POWER_DOMAIN_ARM;
-	packet.on = ~0;
+	packet.domain = cpu_to_le32(RPI_POWER_DOMAIN_ARM);
+	packet.on = cpu_to_le32(~0);
 
 	ret = rpi_firmware_property(rpi_domains->fw,
 				    RPI_FIRMWARE_GET_DOMAIN_STATE,
 				    &packet, sizeof(packet));
 
-	return ret == 0 && packet.on != ~0;
+	return ret == 0 && le32_to_cpu(packet.on) != ~0;
 }
 
 static int rpi_power_probe(struct platform_device *pdev)

drivers/video/fbdev/bcm2708_fb.c

@@ -215,7 +215,7 @@ static int bcm2708_fb_debugfs_init(struct bcm2708_fb *fb)
 static void set_display_num(struct bcm2708_fb *fb)
 {
 	if (fb && fb->fbdev && fb->fbdev->firmware_supports_multifb) {
-		u32 tmp = fb->display_settings.display_num;
+		u32 tmp = cpu_to_le32(fb->display_settings.display_num);
 
 		if (rpi_firmware_property(fb->fbdev->fw,
 					  RPI_FIRMWARE_FRAMEBUFFER_SET_DISPLAY_NUM,
@@ -350,22 +350,22 @@ static int bcm2708_fb_set_par(struct fb_info *info)
 {
 	struct bcm2708_fb *fb = to_bcm2708(info);
 	struct fb_alloc_tags fbinfo = {
-		.tag1 = { RPI_FIRMWARE_FRAMEBUFFER_SET_PHYSICAL_WIDTH_HEIGHT,
-			  8, 0, },
-			.xres = info->var.xres,
-			.yres = info->var.yres,
-		.tag2 = { RPI_FIRMWARE_FRAMEBUFFER_SET_VIRTUAL_WIDTH_HEIGHT,
-			  8, 0, },
-			.xres_virtual = info->var.xres_virtual,
-			.yres_virtual = info->var.yres_virtual,
-		.tag3 = { RPI_FIRMWARE_FRAMEBUFFER_SET_DEPTH, 4, 0 },
-			.bpp = info->var.bits_per_pixel,
-		.tag4 = { RPI_FIRMWARE_FRAMEBUFFER_SET_VIRTUAL_OFFSET, 8, 0 },
-			.xoffset = info->var.xoffset,
-			.yoffset = info->var.yoffset,
-		.tag5 = { RPI_FIRMWARE_FRAMEBUFFER_ALLOCATE, 8, 0 },
+		.tag1 = { cpu_to_le32(RPI_FIRMWARE_FRAMEBUFFER_SET_PHYSICAL_WIDTH_HEIGHT),
+			  cpu_to_le32(8), 0, },
+			.xres = cpu_to_le32(info->var.xres),
+			.yres = cpu_to_le32(info->var.yres),
+		.tag2 = { cpu_to_le32(RPI_FIRMWARE_FRAMEBUFFER_SET_VIRTUAL_WIDTH_HEIGHT),
+			  cpu_to_le32(8), 0, },
+			.xres_virtual = cpu_to_le32(info->var.xres_virtual),
+			.yres_virtual = cpu_to_le32(info->var.yres_virtual),
+		.tag3 = { cpu_to_le32(RPI_FIRMWARE_FRAMEBUFFER_SET_DEPTH), cpu_to_le32(4), 0 },
+			.bpp = cpu_to_le32(info->var.bits_per_pixel),
+		.tag4 = { cpu_to_le32(RPI_FIRMWARE_FRAMEBUFFER_SET_VIRTUAL_OFFSET), cpu_to_le32(8), 0 },
+			.xoffset = cpu_to_le32(info->var.xoffset),
+			.yoffset = cpu_to_le32(info->var.yoffset),
+		.tag5 = { cpu_to_le32(RPI_FIRMWARE_FRAMEBUFFER_ALLOCATE), cpu_to_le32(8), 0 },
 			/* base and screen_size will be initialised later */
-		.tag6 = { RPI_FIRMWARE_FRAMEBUFFER_SET_PITCH, 4, 0 },
+		.tag6 = { cpu_to_le32(RPI_FIRMWARE_FRAMEBUFFER_SET_PITCH), cpu_to_le32(4), 0 },
 			/* pitch will be initialised later */
 	};
 	int ret, image_size;
@@ -384,6 +384,7 @@ static int bcm2708_fb_set_par(struct fb_info *info)
 	set_display_num(fb);
 
 	/* Try allocating our own buffer. We can specify all the parameters */
+        printk(KERN_ERR"xres %d, yres %d, bpp %d\n", info->var.xres, info->var.yres, info->var.bits_per_pixel);
 	image_size = ((info->var.xres * info->var.yres) *
 		      info->var.bits_per_pixel) >> 3;
 
@@ -397,6 +398,7 @@ static int bcm2708_fb_set_par(struct fb_info *info)
 			fb->dma_addr = 0;
 		}
 
+                printk(KERN_ERR"allocating %d bytes\n", image_size);
 		fb->cpuaddr = dma_alloc_coherent(info->device, image_size,
 						 &fb->dma_addr, GFP_KERNEL);
 
@@ -408,14 +410,15 @@ static int bcm2708_fb_set_par(struct fb_info *info)
 		}
 	}
 
+        printk(KERN_ERR"cpu addr 0x%x\n", fb->cpuaddr);
 	if (fb->cpuaddr) {
-		fbinfo.base = fb->dma_addr;
-		fbinfo.screen_size = image_size;
-		fbinfo.pitch = (info->var.xres * info->var.bits_per_pixel) >> 3;
+		fbinfo.base = cpu_to_le32(fb->dma_addr);
+		fbinfo.screen_size = cpu_to_le32(image_size);
+		fbinfo.pitch = cpu_to_le32((info->var.xres * info->var.bits_per_pixel) >> 3);
 
 		ret = rpi_firmware_property_list(fb->fbdev->fw, &fbinfo,
 						 sizeof(fbinfo));
-		if (ret || fbinfo.base != fb->dma_addr) {
+		if (ret || le32_to_cpu(fbinfo.base) != fb->dma_addr) {
 			/* Firmware either failed, or assigned a different base
 			 * address (ie it doesn't support being passed an FB
 			 * allocation).
@@ -442,7 +445,7 @@ static int bcm2708_fb_set_par(struct fb_info *info)
 		 */
 		fbinfo.base = 0;
 		fbinfo.screen_size = 0;
-		fbinfo.tag6.tag = RPI_FIRMWARE_FRAMEBUFFER_GET_PITCH;
+		fbinfo.tag6.tag = cpu_to_le32(RPI_FIRMWARE_FRAMEBUFFER_GET_PITCH);
 		fbinfo.pitch = 0;
 
 		ret = rpi_firmware_property_list(fb->fbdev->fw, &fbinfo,
@@ -460,6 +463,14 @@ static int bcm2708_fb_set_par(struct fb_info *info)
 	else
 		fb->fb.fix.visual = FB_VISUAL_TRUECOLOR;
 
+        fbinfo.base = le32_to_cpu(fbinfo.base);
+        fbinfo.bpp = le32_to_cpu(fbinfo.bpp);
+        fbinfo.pitch = le32_to_cpu(fbinfo.pitch);
+        fbinfo.screen_size = le32_to_cpu(fbinfo.screen_size);
+        fbinfo.xres = le32_to_cpu(fbinfo.xres);
+        fbinfo.yres = le32_to_cpu(fbinfo.yres);
+        fbinfo.yres_virtual = le32_to_cpu(fbinfo.yres_virtual);
+
 	fb->fb.fix.line_length = fbinfo.pitch;
 	fbinfo.base |= 0x40000000;
 	fb->fb_bus_address = fbinfo.base;
@@ -1087,6 +1098,7 @@ static int bcm2708_fb_probe(struct platform_device *dev)
 	ret = rpi_firmware_property(fw,
 				    RPI_FIRMWARE_FRAMEBUFFER_GET_NUM_DISPLAYS,
 				    &num_displays, sizeof(u32));
+        num_displays = le32_to_cpu(num_displays);
 
 	/* If we fail to get the number of displays, or it returns 0, then
 	 * assume old firmware that doesn't have the mailbox call, so just
@@ -1149,19 +1161,23 @@ static int bcm2708_fb_probe(struct platform_device *dev)
 	for (i = 0; i < num_displays; i++) {
 		struct bcm2708_fb *fb = &fbdev->displays[i];
 
-		fb->display_settings.display_num = i;
+		fb->display_settings.display_num = cpu_to_le32(i);
 		fb->dev = dev;
 		fb->fb.device = &dev->dev;
 		fb->fbdev = fbdev;
 
-		fb->gpu.base = gpu_mem.base;
-		fb->gpu.length = gpu_mem.length;
+		fb->gpu.base = le32_to_cpu(gpu_mem.base);
+		fb->gpu.length = le32_to_cpu(gpu_mem.length);
 
 		if (fbdev->firmware_supports_multifb) {
 			ret = rpi_firmware_property(fw,
 						    RPI_FIRMWARE_FRAMEBUFFER_GET_DISPLAY_SETTINGS,
 						    &fb->display_settings,
 						    GET_DISPLAY_SETTINGS_PAYLOAD_SIZE);
+                        fb->display_settings.display_num = le32_to_cpu(fb->display_settings.display_num);
+                        fb->display_settings.width = le32_to_cpu(fb->display_settings.width);
+                        fb->display_settings.height = le32_to_cpu(fb->display_settings.height);
+                        fb->display_settings.depth = le32_to_cpu(fb->display_settings.depth);
 		} else {
 			memset(&fb->display_settings, 0,
 			       sizeof(fb->display_settings));