Eric Lee / smarc-ti-linux-kernel | Embedian Git Server

Commit 3441f04b4b62758a798f9fbbf2047dfedf0329a5

Authored by Anton Blanchard 2014-04-22 13:01:26 +0800

Committed by Benjamin Herrenschmidt 2014-04-28 11:11:23 +0800

Exists in master and in 13 other branches

powerpc/powernv: Create OPAL sglist helper functions and fix endian issues

We have two copies of code that creates an OPAL sg list. Consolidate
these into a common set of helpers and fix the endian issues.

The flash interface embedded a version number in the num_entries
field, whereas the dump interface did did not. Since versioning
wasn't added to the flash interface and it is impossible to add
this in a backwards compatible way, just remove it.

Signed-off-by: Anton Blanchard <anton@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>

Showing 4 changed files with 76 additions and 188 deletions Inline Diff

arch/powerpc/include/asm/opal.h
arch/powerpc/platforms/powernv/opal-dump.c
arch/powerpc/platforms/powernv/opal-flash.c
arch/powerpc/platforms/powernv/opal.c

arch/powerpc/include/asm/opal.h

Diff comments View file @ 3441f04

 /*
  * PowerNV OPAL definitions.
  *
  * Copyright 2011 IBM Corp.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version
  * 2 of the License, or (at your option) any later version.
  */
 #ifndef __OPAL_H
 #define __OPAL_H
 /****** Takeover interface ********/
 /* PAPR H-Call used to querty the HAL existence and/or instanciate
  * it from within pHyp (tech preview only).
  *
  * This is exclusively used in prom_init.c
  */
 #ifndef __ASSEMBLY__
 struct opal_takeover_args {
 	u64	k_image;		/* r4 */
 	u64	k_size;			/* r5 */
 	u64	k_entry;		/* r6 */
 	u64	k_entry2;		/* r7 */
 	u64	hal_addr;		/* r8 */
 	u64	rd_image;		/* r9 */
 	u64	rd_size;		/* r10 */
 	u64	rd_loc;			/* r11 */
 };
 /*
  * SG entry
  *
  * WARNING: The current implementation requires each entry
  * to represent a block that is 4k aligned *and* each block
  * size except the last one in the list to be as well.
  */
 struct opal_sg_entry {
-	void    *data;
+	__be64 data;
-	long    length;
+	__be64 length;
 };
-/* sg list */
+/* SG list */
 struct opal_sg_list {
-	unsigned long num_entries;
+	__be64 length;
-	struct opal_sg_list *next;
+	__be64 next;
 	struct opal_sg_entry entry[];
 };
 /* We calculate number of sg entries based on PAGE_SIZE */
 #define SG_ENTRIES_PER_NODE ((PAGE_SIZE - 16) / sizeof(struct opal_sg_entry))
 extern long opal_query_takeover(u64 *hal_size, u64 *hal_align);
 extern long opal_do_takeover(struct opal_takeover_args *args);
 struct rtas_args;
 extern int opal_enter_rtas(struct rtas_args *args,
 			   unsigned long data,
 			   unsigned long entry);
 #endif /* __ASSEMBLY__ */
 /****** OPAL APIs ******/
 /* Return codes */
 #define OPAL_SUCCESS 		0
 #define OPAL_PARAMETER		-1
 #define OPAL_BUSY		-2
 #define OPAL_PARTIAL		-3
 #define OPAL_CONSTRAINED	-4
 #define OPAL_CLOSED		-5
 #define OPAL_HARDWARE		-6
 #define OPAL_UNSUPPORTED	-7
 #define OPAL_PERMISSION		-8
 #define OPAL_NO_MEM		-9
 #define OPAL_RESOURCE		-10
 #define OPAL_INTERNAL_ERROR	-11
 #define OPAL_BUSY_EVENT		-12
 #define OPAL_HARDWARE_FROZEN	-13
 #define OPAL_WRONG_STATE	-14
 #define OPAL_ASYNC_COMPLETION	-15
 /* API Tokens (in r0) */
 #define OPAL_INVALID_CALL			-1
 #define OPAL_CONSOLE_WRITE			1
 #define OPAL_CONSOLE_READ			2
 #define OPAL_RTC_READ				3
 #define OPAL_RTC_WRITE				4
 #define OPAL_CEC_POWER_DOWN			5
 #define OPAL_CEC_REBOOT				6
 #define OPAL_READ_NVRAM				7
 #define OPAL_WRITE_NVRAM			8
 #define OPAL_HANDLE_INTERRUPT			9
 #define OPAL_POLL_EVENTS			10
 #define OPAL_PCI_SET_HUB_TCE_MEMORY		11
 #define OPAL_PCI_SET_PHB_TCE_MEMORY		12
 #define OPAL_PCI_CONFIG_READ_BYTE		13
 #define OPAL_PCI_CONFIG_READ_HALF_WORD  	14
 #define OPAL_PCI_CONFIG_READ_WORD		15
 #define OPAL_PCI_CONFIG_WRITE_BYTE		16
 #define OPAL_PCI_CONFIG_WRITE_HALF_WORD		17
 #define OPAL_PCI_CONFIG_WRITE_WORD		18
 #define OPAL_SET_XIVE				19
 #define OPAL_GET_XIVE				20
 #define OPAL_GET_COMPLETION_TOKEN_STATUS	21 /* obsolete */
 #define OPAL_REGISTER_OPAL_EXCEPTION_HANDLER	22
 #define OPAL_PCI_EEH_FREEZE_STATUS		23
 #define OPAL_PCI_SHPC				24
 #define OPAL_CONSOLE_WRITE_BUFFER_SPACE		25
 #define OPAL_PCI_EEH_FREEZE_CLEAR		26
 #define OPAL_PCI_PHB_MMIO_ENABLE		27
 #define OPAL_PCI_SET_PHB_MEM_WINDOW		28
 #define OPAL_PCI_MAP_PE_MMIO_WINDOW		29
 #define OPAL_PCI_SET_PHB_TABLE_MEMORY		30
 #define OPAL_PCI_SET_PE				31
 #define OPAL_PCI_SET_PELTV			32
 #define OPAL_PCI_SET_MVE			33
 #define OPAL_PCI_SET_MVE_ENABLE			34
 #define OPAL_PCI_GET_XIVE_REISSUE		35
 #define OPAL_PCI_SET_XIVE_REISSUE		36
 #define OPAL_PCI_SET_XIVE_PE			37
 #define OPAL_GET_XIVE_SOURCE			38
 #define OPAL_GET_MSI_32				39
 #define OPAL_GET_MSI_64				40
 #define OPAL_START_CPU				41
 #define OPAL_QUERY_CPU_STATUS			42
 #define OPAL_WRITE_OPPANEL			43
 #define OPAL_PCI_MAP_PE_DMA_WINDOW		44
 #define OPAL_PCI_MAP_PE_DMA_WINDOW_REAL		45
 #define OPAL_PCI_RESET				49
 #define OPAL_PCI_GET_HUB_DIAG_DATA		50
 #define OPAL_PCI_GET_PHB_DIAG_DATA		51
 #define OPAL_PCI_FENCE_PHB			52
 #define OPAL_PCI_REINIT				53
 #define OPAL_PCI_MASK_PE_ERROR			54
 #define OPAL_SET_SLOT_LED_STATUS		55
 #define OPAL_GET_EPOW_STATUS			56
 #define OPAL_SET_SYSTEM_ATTENTION_LED		57
 #define OPAL_RESERVED1				58
 #define OPAL_RESERVED2				59
 #define OPAL_PCI_NEXT_ERROR			60
 #define OPAL_PCI_EEH_FREEZE_STATUS2		61
 #define OPAL_PCI_POLL				62
 #define OPAL_PCI_MSI_EOI			63
 #define OPAL_PCI_GET_PHB_DIAG_DATA2		64
 #define OPAL_XSCOM_READ				65
 #define OPAL_XSCOM_WRITE			66
 #define OPAL_LPC_READ				67
 #define OPAL_LPC_WRITE				68
 #define OPAL_RETURN_CPU				69
 #define OPAL_ELOG_READ				71
 #define OPAL_ELOG_WRITE				72
 #define OPAL_ELOG_ACK				73
 #define OPAL_ELOG_RESEND			74
 #define OPAL_ELOG_SIZE				75
 #define OPAL_FLASH_VALIDATE			76
 #define OPAL_FLASH_MANAGE			77
 #define OPAL_FLASH_UPDATE			78
 #define OPAL_RESYNC_TIMEBASE			79
 #define OPAL_DUMP_INIT				81
 #define OPAL_DUMP_INFO				82
 #define OPAL_DUMP_READ				83
 #define OPAL_DUMP_ACK				84
 #define OPAL_GET_MSG				85
 #define OPAL_CHECK_ASYNC_COMPLETION		86
 #define OPAL_SYNC_HOST_REBOOT			87
 #define OPAL_SENSOR_READ			88
 #define OPAL_GET_PARAM				89
 #define OPAL_SET_PARAM				90
 #define OPAL_DUMP_RESEND			91
 #define OPAL_DUMP_INFO2				94
 #ifndef __ASSEMBLY__
 #include <linux/notifier.h>
 /* Other enums */
 enum OpalVendorApiTokens {
 	OPAL_START_VENDOR_API_RANGE = 1000, OPAL_END_VENDOR_API_RANGE = 1999
 };
 enum OpalFreezeState {
 	OPAL_EEH_STOPPED_NOT_FROZEN = 0,
 	OPAL_EEH_STOPPED_MMIO_FREEZE = 1,
 	OPAL_EEH_STOPPED_DMA_FREEZE = 2,
 	OPAL_EEH_STOPPED_MMIO_DMA_FREEZE = 3,
 	OPAL_EEH_STOPPED_RESET = 4,
 	OPAL_EEH_STOPPED_TEMP_UNAVAIL = 5,
 	OPAL_EEH_STOPPED_PERM_UNAVAIL = 6
 };
 enum OpalEehFreezeActionToken {
 	OPAL_EEH_ACTION_CLEAR_FREEZE_MMIO = 1,
 	OPAL_EEH_ACTION_CLEAR_FREEZE_DMA = 2,
 	OPAL_EEH_ACTION_CLEAR_FREEZE_ALL = 3
 };
 enum OpalPciStatusToken {
 	OPAL_EEH_NO_ERROR	= 0,
 	OPAL_EEH_IOC_ERROR	= 1,
 	OPAL_EEH_PHB_ERROR	= 2,
 	OPAL_EEH_PE_ERROR	= 3,
 	OPAL_EEH_PE_MMIO_ERROR	= 4,
 	OPAL_EEH_PE_DMA_ERROR	= 5
 };
 enum OpalPciErrorSeverity {
 	OPAL_EEH_SEV_NO_ERROR	= 0,
 	OPAL_EEH_SEV_IOC_DEAD	= 1,
 	OPAL_EEH_SEV_PHB_DEAD	= 2,
 	OPAL_EEH_SEV_PHB_FENCED	= 3,
 	OPAL_EEH_SEV_PE_ER	= 4,
 	OPAL_EEH_SEV_INF	= 5
 };
 enum OpalShpcAction {
 	OPAL_SHPC_GET_LINK_STATE = 0,
 	OPAL_SHPC_GET_SLOT_STATE = 1
 };
 enum OpalShpcLinkState {
 	OPAL_SHPC_LINK_DOWN = 0,
 	OPAL_SHPC_LINK_UP = 1
 };
 enum OpalMmioWindowType {
 	OPAL_M32_WINDOW_TYPE = 1,
 	OPAL_M64_WINDOW_TYPE = 2,
 	OPAL_IO_WINDOW_TYPE = 3
 };
 enum OpalShpcSlotState {
 	OPAL_SHPC_DEV_NOT_PRESENT = 0,
 	OPAL_SHPC_DEV_PRESENT = 1
 };
 enum OpalExceptionHandler {
 	OPAL_MACHINE_CHECK_HANDLER = 1,
 	OPAL_HYPERVISOR_MAINTENANCE_HANDLER = 2,
 	OPAL_SOFTPATCH_HANDLER = 3
 };
 enum OpalPendingState {
 	OPAL_EVENT_OPAL_INTERNAL	= 0x1,
 	OPAL_EVENT_NVRAM		= 0x2,
 	OPAL_EVENT_RTC			= 0x4,
 	OPAL_EVENT_CONSOLE_OUTPUT	= 0x8,
 	OPAL_EVENT_CONSOLE_INPUT	= 0x10,
 	OPAL_EVENT_ERROR_LOG_AVAIL	= 0x20,
 	OPAL_EVENT_ERROR_LOG		= 0x40,
 	OPAL_EVENT_EPOW			= 0x80,
 	OPAL_EVENT_LED_STATUS		= 0x100,
 	OPAL_EVENT_PCI_ERROR		= 0x200,
 	OPAL_EVENT_DUMP_AVAIL		= 0x400,
 	OPAL_EVENT_MSG_PENDING		= 0x800,
 };
 enum OpalMessageType {
 	OPAL_MSG_ASYNC_COMP = 0,	/* params[0] = token, params[1] = rc,
 					 * additional params function-specific
 					 */
 	OPAL_MSG_MEM_ERR,
 	OPAL_MSG_EPOW,
 	OPAL_MSG_SHUTDOWN,
 	OPAL_MSG_TYPE_MAX,
 };
 /* Machine check related definitions */
 enum OpalMCE_Version {
 	OpalMCE_V1 = 1,
 };
 enum OpalMCE_Severity {
 	OpalMCE_SEV_NO_ERROR = 0,
 	OpalMCE_SEV_WARNING = 1,
 	OpalMCE_SEV_ERROR_SYNC = 2,
 	OpalMCE_SEV_FATAL = 3,
 };
 enum OpalMCE_Disposition {
 	OpalMCE_DISPOSITION_RECOVERED = 0,
 	OpalMCE_DISPOSITION_NOT_RECOVERED = 1,
 };
 enum OpalMCE_Initiator {
 	OpalMCE_INITIATOR_UNKNOWN = 0,
 	OpalMCE_INITIATOR_CPU = 1,
 };
 enum OpalMCE_ErrorType {
 	OpalMCE_ERROR_TYPE_UNKNOWN = 0,
 	OpalMCE_ERROR_TYPE_UE = 1,
 	OpalMCE_ERROR_TYPE_SLB = 2,
 	OpalMCE_ERROR_TYPE_ERAT = 3,
 	OpalMCE_ERROR_TYPE_TLB = 4,
 };
 enum OpalMCE_UeErrorType {
 	OpalMCE_UE_ERROR_INDETERMINATE = 0,
 	OpalMCE_UE_ERROR_IFETCH = 1,
 	OpalMCE_UE_ERROR_PAGE_TABLE_WALK_IFETCH = 2,
 	OpalMCE_UE_ERROR_LOAD_STORE = 3,
 	OpalMCE_UE_ERROR_PAGE_TABLE_WALK_LOAD_STORE = 4,
 };
 enum OpalMCE_SlbErrorType {
 	OpalMCE_SLB_ERROR_INDETERMINATE = 0,
 	OpalMCE_SLB_ERROR_PARITY = 1,
 	OpalMCE_SLB_ERROR_MULTIHIT = 2,
 };
 enum OpalMCE_EratErrorType {
 	OpalMCE_ERAT_ERROR_INDETERMINATE = 0,
 	OpalMCE_ERAT_ERROR_PARITY = 1,
 	OpalMCE_ERAT_ERROR_MULTIHIT = 2,
 };
 enum OpalMCE_TlbErrorType {
 	OpalMCE_TLB_ERROR_INDETERMINATE = 0,
 	OpalMCE_TLB_ERROR_PARITY = 1,
 	OpalMCE_TLB_ERROR_MULTIHIT = 2,
 };
 enum OpalThreadStatus {
 	OPAL_THREAD_INACTIVE = 0x0,
 	OPAL_THREAD_STARTED = 0x1,
 	OPAL_THREAD_UNAVAILABLE = 0x2 /* opal-v3 */
 };
 enum OpalPciBusCompare {
 	OpalPciBusAny	= 0,	/* Any bus number match */
 	OpalPciBus3Bits	= 2,	/* Match top 3 bits of bus number */
 	OpalPciBus4Bits	= 3,	/* Match top 4 bits of bus number */
 	OpalPciBus5Bits	= 4,	/* Match top 5 bits of bus number */
 	OpalPciBus6Bits	= 5,	/* Match top 6 bits of bus number */
 	OpalPciBus7Bits	= 6,	/* Match top 7 bits of bus number */
 	OpalPciBusAll	= 7,	/* Match bus number exactly */
 };
 enum OpalDeviceCompare {
 	OPAL_IGNORE_RID_DEVICE_NUMBER = 0,
 	OPAL_COMPARE_RID_DEVICE_NUMBER = 1
 };
 enum OpalFuncCompare {
 	OPAL_IGNORE_RID_FUNCTION_NUMBER = 0,
 	OPAL_COMPARE_RID_FUNCTION_NUMBER = 1
 };
 enum OpalPeAction {
 	OPAL_UNMAP_PE = 0,
 	OPAL_MAP_PE = 1
 };
 enum OpalPeltvAction {
 	OPAL_REMOVE_PE_FROM_DOMAIN = 0,
 	OPAL_ADD_PE_TO_DOMAIN = 1
 };
 enum OpalMveEnableAction {
 	OPAL_DISABLE_MVE = 0,
 	OPAL_ENABLE_MVE = 1
 };
 enum OpalPciResetScope {
 	OPAL_PHB_COMPLETE = 1, OPAL_PCI_LINK = 2, OPAL_PHB_ERROR = 3,
 	OPAL_PCI_HOT_RESET = 4, OPAL_PCI_FUNDAMENTAL_RESET = 5,
 	OPAL_PCI_IODA_TABLE_RESET = 6,
 };
 enum OpalPciReinitScope {
 	OPAL_REINIT_PCI_DEV = 1000
 };
 enum OpalPciResetState {
 	OPAL_DEASSERT_RESET = 0,
 	OPAL_ASSERT_RESET = 1
 };
 enum OpalPciMaskAction {
 	OPAL_UNMASK_ERROR_TYPE = 0,
 	OPAL_MASK_ERROR_TYPE = 1
 };
 enum OpalSlotLedType {
 	OPAL_SLOT_LED_ID_TYPE = 0,
 	OPAL_SLOT_LED_FAULT_TYPE = 1
 };
 enum OpalLedAction {
 	OPAL_TURN_OFF_LED = 0,
 	OPAL_TURN_ON_LED = 1,
 	OPAL_QUERY_LED_STATE_AFTER_BUSY = 2
 };
 enum OpalEpowStatus {
 	OPAL_EPOW_NONE = 0,
 	OPAL_EPOW_UPS = 1,
 	OPAL_EPOW_OVER_AMBIENT_TEMP = 2,
 	OPAL_EPOW_OVER_INTERNAL_TEMP = 3
 };
 /*
  * Address cycle types for LPC accesses. These also correspond
  * to the content of the first cell of the "reg" property for
  * device nodes on the LPC bus
  */
 enum OpalLPCAddressType {
 	OPAL_LPC_MEM	= 0,
 	OPAL_LPC_IO	= 1,
 	OPAL_LPC_FW	= 2,
 };
 /* System parameter permission */
 enum OpalSysparamPerm {
 	OPAL_SYSPARAM_READ      = 0x1,
 	OPAL_SYSPARAM_WRITE     = 0x2,
 	OPAL_SYSPARAM_RW        = (OPAL_SYSPARAM_READ | OPAL_SYSPARAM_WRITE),
 };
 struct opal_msg {
 	__be32 msg_type;
 	__be32 reserved;
 	__be64 params[8];
 };
 struct opal_machine_check_event {
 	enum OpalMCE_Version	version:8;	/* 0x00 */
 	uint8_t			in_use;		/* 0x01 */
 	enum OpalMCE_Severity	severity:8;	/* 0x02 */
 	enum OpalMCE_Initiator	initiator:8;	/* 0x03 */
 	enum OpalMCE_ErrorType	error_type:8;	/* 0x04 */
 	enum OpalMCE_Disposition disposition:8; /* 0x05 */
 	uint8_t			reserved_1[2];	/* 0x06 */
 	uint64_t		gpr3;		/* 0x08 */
 	uint64_t		srr0;		/* 0x10 */
 	uint64_t		srr1;		/* 0x18 */
 	union {					/* 0x20 */
 		struct {
 			enum OpalMCE_UeErrorType ue_error_type:8;
 			uint8_t		effective_address_provided;
 			uint8_t		physical_address_provided;
 			uint8_t		reserved_1[5];
 			uint64_t	effective_address;
 			uint64_t	physical_address;
 			uint8_t		reserved_2[8];
 		} ue_error;
 		struct {
 			enum OpalMCE_SlbErrorType slb_error_type:8;
 			uint8_t		effective_address_provided;
 			uint8_t		reserved_1[6];
 			uint64_t	effective_address;
 			uint8_t		reserved_2[16];
 		} slb_error;
 		struct {
 			enum OpalMCE_EratErrorType erat_error_type:8;
 			uint8_t		effective_address_provided;
 			uint8_t		reserved_1[6];
 			uint64_t	effective_address;
 			uint8_t		reserved_2[16];
 		} erat_error;
 		struct {
 			enum OpalMCE_TlbErrorType tlb_error_type:8;
 			uint8_t		effective_address_provided;
 			uint8_t		reserved_1[6];
 			uint64_t	effective_address;
 			uint8_t		reserved_2[16];
 		} tlb_error;
 	} u;
 };
 /* FSP memory errors handling */
 enum OpalMemErr_Version {
 	OpalMemErr_V1 = 1,
 };
 enum OpalMemErrType {
 	OPAL_MEM_ERR_TYPE_RESILIENCE	= 0,
 	OPAL_MEM_ERR_TYPE_DYN_DALLOC,
 	OPAL_MEM_ERR_TYPE_SCRUB,
 };
 /* Memory Reilience error type */
 enum OpalMemErr_ResilErrType {
 	OPAL_MEM_RESILIENCE_CE		= 0,
 	OPAL_MEM_RESILIENCE_UE,
 	OPAL_MEM_RESILIENCE_UE_SCRUB,
 };
 /* Dynamic Memory Deallocation type */
 enum OpalMemErr_DynErrType {
 	OPAL_MEM_DYNAMIC_DEALLOC	= 0,
 };
 /* OpalMemoryErrorData->flags */
 #define OPAL_MEM_CORRECTED_ERROR	0x0001
 #define OPAL_MEM_THRESHOLD_EXCEEDED	0x0002
 #define OPAL_MEM_ACK_REQUIRED		0x8000
 struct OpalMemoryErrorData {
 	enum OpalMemErr_Version	version:8;	/* 0x00 */
 	enum OpalMemErrType	type:8;		/* 0x01 */
 	uint16_t		flags;		/* 0x02 */
 	uint8_t			reserved_1[4];	/* 0x04 */
 	union {
 		/* Memory Resilience corrected/uncorrected error info */
 		struct {
 			enum OpalMemErr_ResilErrType resil_err_type:8;
 			uint8_t		reserved_1[7];
 			uint64_t	physical_address_start;
 			uint64_t	physical_address_end;
 		} resilience;
 		/* Dynamic memory deallocation error info */
 		struct {
 			enum OpalMemErr_DynErrType dyn_err_type:8;
 			uint8_t		reserved_1[7];
 			uint64_t	physical_address_start;
 			uint64_t	physical_address_end;
 		} dyn_dealloc;
 	} u;
 };
 enum {
 	OPAL_P7IOC_DIAG_TYPE_NONE	= 0,
 	OPAL_P7IOC_DIAG_TYPE_RGC	= 1,
 	OPAL_P7IOC_DIAG_TYPE_BI		= 2,
 	OPAL_P7IOC_DIAG_TYPE_CI		= 3,
 	OPAL_P7IOC_DIAG_TYPE_MISC	= 4,
 	OPAL_P7IOC_DIAG_TYPE_I2C	= 5,
 	OPAL_P7IOC_DIAG_TYPE_LAST	= 6
 };
 struct OpalIoP7IOCErrorData {
 	uint16_t type;
 	/* GEM */
 	uint64_t gemXfir;
 	uint64_t gemRfir;
 	uint64_t gemRirqfir;
 	uint64_t gemMask;
 	uint64_t gemRwof;
 	/* LEM */
 	uint64_t lemFir;
 	uint64_t lemErrMask;
 	uint64_t lemAction0;
 	uint64_t lemAction1;
 	uint64_t lemWof;
 	union {
 		struct OpalIoP7IOCRgcErrorData {
 			uint64_t rgcStatus;		/* 3E1C10 */
 			uint64_t rgcLdcp;		/* 3E1C18 */
 		}rgc;
 		struct OpalIoP7IOCBiErrorData {
 			uint64_t biLdcp0;		/* 3C0100, 3C0118 */
 			uint64_t biLdcp1;		/* 3C0108, 3C0120 */
 			uint64_t biLdcp2;		/* 3C0110, 3C0128 */
 			uint64_t biFenceStatus;		/* 3C0130, 3C0130 */
 			uint8_t  biDownbound;		/* BI Downbound or Upbound */
 		}bi;
 		struct OpalIoP7IOCCiErrorData {
 			uint64_t ciPortStatus;		/* 3Dn008 */
 			uint64_t ciPortLdcp;		/* 3Dn010 */
 			uint8_t	 ciPort;		/* Index of CI port: 0/1 */
 		}ci;
 	};
 };
 /**
  * This structure defines the overlay which will be used to store PHB error
  * data upon request.
  */
 enum {
 	OPAL_PHB_ERROR_DATA_VERSION_1 = 1,
 };
 enum {
 	OPAL_PHB_ERROR_DATA_TYPE_P7IOC = 1,
 	OPAL_PHB_ERROR_DATA_TYPE_PHB3 = 2
 };
 enum {
 	OPAL_P7IOC_NUM_PEST_REGS = 128,
 	OPAL_PHB3_NUM_PEST_REGS = 256
 };
 struct OpalIoPhbErrorCommon {
 	uint32_t version;
 	uint32_t ioType;
 	uint32_t len;
 };
 struct OpalIoP7IOCPhbErrorData {
 	struct OpalIoPhbErrorCommon common;
 	uint32_t brdgCtl;
 	// P7IOC utl regs
 	uint32_t portStatusReg;
 	uint32_t rootCmplxStatus;
 	uint32_t busAgentStatus;
 	// P7IOC cfg regs
 	uint32_t deviceStatus;
 	uint32_t slotStatus;
 	uint32_t linkStatus;
 	uint32_t devCmdStatus;
 	uint32_t devSecStatus;
 	// cfg AER regs
 	uint32_t rootErrorStatus;
 	uint32_t uncorrErrorStatus;
 	uint32_t corrErrorStatus;
 	uint32_t tlpHdr1;
 	uint32_t tlpHdr2;
 	uint32_t tlpHdr3;
 	uint32_t tlpHdr4;
 	uint32_t sourceId;
 	uint32_t rsv3;
 	// Record data about the call to allocate a buffer.
 	uint64_t errorClass;
 	uint64_t correlator;
 	//P7IOC MMIO Error Regs
 	uint64_t p7iocPlssr;                // n120
 	uint64_t p7iocCsr;                  // n110
 	uint64_t lemFir;                    // nC00
 	uint64_t lemErrorMask;              // nC18
 	uint64_t lemWOF;                    // nC40
 	uint64_t phbErrorStatus;            // nC80
 	uint64_t phbFirstErrorStatus;       // nC88
 	uint64_t phbErrorLog0;              // nCC0
 	uint64_t phbErrorLog1;              // nCC8
 	uint64_t mmioErrorStatus;           // nD00
 	uint64_t mmioFirstErrorStatus;      // nD08
 	uint64_t mmioErrorLog0;             // nD40
 	uint64_t mmioErrorLog1;             // nD48
 	uint64_t dma0ErrorStatus;           // nD80
 	uint64_t dma0FirstErrorStatus;      // nD88
 	uint64_t dma0ErrorLog0;             // nDC0
 	uint64_t dma0ErrorLog1;             // nDC8
 	uint64_t dma1ErrorStatus;           // nE00
 	uint64_t dma1FirstErrorStatus;      // nE08
 	uint64_t dma1ErrorLog0;             // nE40
 	uint64_t dma1ErrorLog1;             // nE48
 	uint64_t pestA[OPAL_P7IOC_NUM_PEST_REGS];
 	uint64_t pestB[OPAL_P7IOC_NUM_PEST_REGS];
 };
 struct OpalIoPhb3ErrorData {
 	struct OpalIoPhbErrorCommon common;
 	uint32_t brdgCtl;
 	/* PHB3 UTL regs */
 	uint32_t portStatusReg;
 	uint32_t rootCmplxStatus;
 	uint32_t busAgentStatus;
 	/* PHB3 cfg regs */
 	uint32_t deviceStatus;
 	uint32_t slotStatus;
 	uint32_t linkStatus;
 	uint32_t devCmdStatus;
 	uint32_t devSecStatus;
 	/* cfg AER regs */
 	uint32_t rootErrorStatus;
 	uint32_t uncorrErrorStatus;
 	uint32_t corrErrorStatus;
 	uint32_t tlpHdr1;
 	uint32_t tlpHdr2;
 	uint32_t tlpHdr3;
 	uint32_t tlpHdr4;
 	uint32_t sourceId;
 	uint32_t rsv3;
 	/* Record data about the call to allocate a buffer */
 	uint64_t errorClass;
 	uint64_t correlator;
 	uint64_t nFir;			/* 000 */
 	uint64_t nFirMask;		/* 003 */
 	uint64_t nFirWOF;		/* 008 */
 	/* PHB3 MMIO Error Regs */
 	uint64_t phbPlssr;		/* 120 */
 	uint64_t phbCsr;		/* 110 */
 	uint64_t lemFir;		/* C00 */
 	uint64_t lemErrorMask;		/* C18 */
 	uint64_t lemWOF;		/* C40 */
 	uint64_t phbErrorStatus;	/* C80 */
 	uint64_t phbFirstErrorStatus;	/* C88 */
 	uint64_t phbErrorLog0;		/* CC0 */
 	uint64_t phbErrorLog1;		/* CC8 */
 	uint64_t mmioErrorStatus;	/* D00 */
 	uint64_t mmioFirstErrorStatus;	/* D08 */
 	uint64_t mmioErrorLog0;		/* D40 */
 	uint64_t mmioErrorLog1;		/* D48 */
 	uint64_t dma0ErrorStatus;	/* D80 */
 	uint64_t dma0FirstErrorStatus;	/* D88 */
 	uint64_t dma0ErrorLog0;		/* DC0 */
 	uint64_t dma0ErrorLog1;		/* DC8 */
 	uint64_t dma1ErrorStatus;	/* E00 */
 	uint64_t dma1FirstErrorStatus;	/* E08 */
 	uint64_t dma1ErrorLog0;		/* E40 */
 	uint64_t dma1ErrorLog1;		/* E48 */
 	uint64_t pestA[OPAL_PHB3_NUM_PEST_REGS];
 	uint64_t pestB[OPAL_PHB3_NUM_PEST_REGS];
 };
 typedef struct oppanel_line {
 	const char * 	line;
 	uint64_t 	line_len;
 } oppanel_line_t;
 /* /sys/firmware/opal */
 extern struct kobject *opal_kobj;
 /* /ibm,opal */
 extern struct device_node *opal_node;
 /* API functions */
 int64_t opal_invalid_call(void);
 int64_t opal_console_write(int64_t term_number, __be64 *length,
 			   const uint8_t *buffer);
 int64_t opal_console_read(int64_t term_number, __be64 *length,
 			  uint8_t *buffer);
 int64_t opal_console_write_buffer_space(int64_t term_number,
 					__be64 *length);
 int64_t opal_rtc_read(__be32 *year_month_day,
 		      __be64 *hour_minute_second_millisecond);
 int64_t opal_rtc_write(uint32_t year_month_day,
 		       uint64_t hour_minute_second_millisecond);
 int64_t opal_cec_power_down(uint64_t request);
 int64_t opal_cec_reboot(void);
 int64_t opal_read_nvram(uint64_t buffer, uint64_t size, uint64_t offset);
 int64_t opal_write_nvram(uint64_t buffer, uint64_t size, uint64_t offset);
 int64_t opal_handle_interrupt(uint64_t isn, __be64 *outstanding_event_mask);
 int64_t opal_poll_events(__be64 *outstanding_event_mask);
 int64_t opal_pci_set_hub_tce_memory(uint64_t hub_id, uint64_t tce_mem_addr,
 				    uint64_t tce_mem_size);
 int64_t opal_pci_set_phb_tce_memory(uint64_t phb_id, uint64_t tce_mem_addr,
 				    uint64_t tce_mem_size);
 int64_t opal_pci_config_read_byte(uint64_t phb_id, uint64_t bus_dev_func,
 				  uint64_t offset, uint8_t *data);
 int64_t opal_pci_config_read_half_word(uint64_t phb_id, uint64_t bus_dev_func,
 				       uint64_t offset, __be16 *data);
 int64_t opal_pci_config_read_word(uint64_t phb_id, uint64_t bus_dev_func,
 				  uint64_t offset, __be32 *data);
 int64_t opal_pci_config_write_byte(uint64_t phb_id, uint64_t bus_dev_func,
 				   uint64_t offset, uint8_t data);
 int64_t opal_pci_config_write_half_word(uint64_t phb_id, uint64_t bus_dev_func,
 					uint64_t offset, uint16_t data);
 int64_t opal_pci_config_write_word(uint64_t phb_id, uint64_t bus_dev_func,
 				   uint64_t offset, uint32_t data);
 int64_t opal_set_xive(uint32_t isn, uint16_t server, uint8_t priority);
 int64_t opal_get_xive(uint32_t isn, __be16 *server, uint8_t *priority);
 int64_t opal_register_exception_handler(uint64_t opal_exception,
 					uint64_t handler_address,
 					uint64_t glue_cache_line);
 int64_t opal_pci_eeh_freeze_status(uint64_t phb_id, uint64_t pe_number,
 				   uint8_t *freeze_state,
 				   __be16 *pci_error_type,
 				   __be64 *phb_status);
 int64_t opal_pci_eeh_freeze_clear(uint64_t phb_id, uint64_t pe_number,
 				  uint64_t eeh_action_token);
 int64_t opal_pci_shpc(uint64_t phb_id, uint64_t shpc_action, uint8_t *state);
 int64_t opal_pci_phb_mmio_enable(uint64_t phb_id, uint16_t window_type,
 				 uint16_t window_num, uint16_t enable);
 int64_t opal_pci_set_phb_mem_window(uint64_t phb_id, uint16_t window_type,
 				    uint16_t window_num,
 				    uint64_t starting_real_address,
 				    uint64_t starting_pci_address,
 				    uint16_t segment_size);
 int64_t opal_pci_map_pe_mmio_window(uint64_t phb_id, uint16_t pe_number,
 				    uint16_t window_type, uint16_t window_num,
 				    uint16_t segment_num);
 int64_t opal_pci_set_phb_table_memory(uint64_t phb_id, uint64_t rtt_addr,
 				      uint64_t ivt_addr, uint64_t ivt_len,
 				      uint64_t reject_array_addr,
 				      uint64_t peltv_addr);
 int64_t opal_pci_set_pe(uint64_t phb_id, uint64_t pe_number, uint64_t bus_dev_func,
 			uint8_t bus_compare, uint8_t dev_compare, uint8_t func_compare,
 			uint8_t pe_action);
 int64_t opal_pci_set_peltv(uint64_t phb_id, uint32_t parent_pe, uint32_t child_pe,
 			   uint8_t state);
 int64_t opal_pci_set_mve(uint64_t phb_id, uint32_t mve_number, uint32_t pe_number);
 int64_t opal_pci_set_mve_enable(uint64_t phb_id, uint32_t mve_number,
 				uint32_t state);
 int64_t opal_pci_get_xive_reissue(uint64_t phb_id, uint32_t xive_number,
 				  uint8_t *p_bit, uint8_t *q_bit);
 int64_t opal_pci_set_xive_reissue(uint64_t phb_id, uint32_t xive_number,
 				  uint8_t p_bit, uint8_t q_bit);
 int64_t opal_pci_msi_eoi(uint64_t phb_id, uint32_t hw_irq);
 int64_t opal_pci_set_xive_pe(uint64_t phb_id, uint32_t pe_number,
 			     uint32_t xive_num);
 int64_t opal_get_xive_source(uint64_t phb_id, uint32_t xive_num,
 			     __be32 *interrupt_source_number);
 int64_t opal_get_msi_32(uint64_t phb_id, uint32_t mve_number, uint32_t xive_num,
 			uint8_t msi_range, __be32 *msi_address,
 			__be32 *message_data);
 int64_t opal_get_msi_64(uint64_t phb_id, uint32_t mve_number,
 			uint32_t xive_num, uint8_t msi_range,
 			__be64 *msi_address, __be32 *message_data);
 int64_t opal_start_cpu(uint64_t thread_number, uint64_t start_address);
 int64_t opal_query_cpu_status(uint64_t thread_number, uint8_t *thread_status);
 int64_t opal_write_oppanel(oppanel_line_t *lines, uint64_t num_lines);
 int64_t opal_pci_map_pe_dma_window(uint64_t phb_id, uint16_t pe_number, uint16_t window_id,
 				   uint16_t tce_levels, uint64_t tce_table_addr,
 				   uint64_t tce_table_size, uint64_t tce_page_size);
 int64_t opal_pci_map_pe_dma_window_real(uint64_t phb_id, uint16_t pe_number,
 					uint16_t dma_window_number, uint64_t pci_start_addr,
 					uint64_t pci_mem_size);
 int64_t opal_pci_reset(uint64_t phb_id, uint8_t reset_scope, uint8_t assert_state);
 int64_t opal_pci_get_hub_diag_data(uint64_t hub_id, void *diag_buffer,
 				   uint64_t diag_buffer_len);
 int64_t opal_pci_get_phb_diag_data(uint64_t phb_id, void *diag_buffer,
 				   uint64_t diag_buffer_len);
 int64_t opal_pci_get_phb_diag_data2(uint64_t phb_id, void *diag_buffer,
 				    uint64_t diag_buffer_len);
 int64_t opal_pci_fence_phb(uint64_t phb_id);
 int64_t opal_pci_reinit(uint64_t phb_id, uint64_t reinit_scope, uint64_t data);
 int64_t opal_pci_mask_pe_error(uint64_t phb_id, uint16_t pe_number, uint8_t error_type, uint8_t mask_action);
 int64_t opal_set_slot_led_status(uint64_t phb_id, uint64_t slot_id, uint8_t led_type, uint8_t led_action);
 int64_t opal_get_epow_status(__be64 *status);
 int64_t opal_set_system_attention_led(uint8_t led_action);
 int64_t opal_pci_next_error(uint64_t phb_id, uint64_t *first_frozen_pe,
 			    uint16_t *pci_error_type, uint16_t *severity);
 int64_t opal_pci_poll(uint64_t phb_id);
 int64_t opal_return_cpu(void);
 int64_t opal_xscom_read(uint32_t gcid, uint64_t pcb_addr, __be64 *val);
 int64_t opal_xscom_write(uint32_t gcid, uint64_t pcb_addr, uint64_t val);
 int64_t opal_lpc_write(uint32_t chip_id, enum OpalLPCAddressType addr_type,
 		       uint32_t addr, uint32_t data, uint32_t sz);
 int64_t opal_lpc_read(uint32_t chip_id, enum OpalLPCAddressType addr_type,
 		      uint32_t addr, __be32 *data, uint32_t sz);
 int64_t opal_read_elog(uint64_t buffer, uint64_t size, uint64_t log_id);
 int64_t opal_get_elog_size(__be64 *log_id, __be64 *size, __be64 *elog_type);
 int64_t opal_write_elog(uint64_t buffer, uint64_t size, uint64_t offset);
 int64_t opal_send_ack_elog(uint64_t log_id);
 void opal_resend_pending_logs(void);
 int64_t opal_validate_flash(uint64_t buffer, uint32_t *size, uint32_t *result);
 int64_t opal_manage_flash(uint8_t op);
 int64_t opal_update_flash(uint64_t blk_list);
 int64_t opal_dump_init(uint8_t dump_type);
 int64_t opal_dump_info(uint32_t *dump_id, uint32_t *dump_size);
 int64_t opal_dump_info2(uint32_t *dump_id, uint32_t *dump_size, uint32_t *dump_type);
 int64_t opal_dump_read(uint32_t dump_id, uint64_t buffer);
 int64_t opal_dump_ack(uint32_t dump_id);
 int64_t opal_dump_resend_notification(void);
 int64_t opal_get_msg(uint64_t buffer, uint64_t size);
 int64_t opal_check_completion(uint64_t buffer, uint64_t size, uint64_t token);
 int64_t opal_sync_host_reboot(void);
 int64_t opal_get_param(uint64_t token, uint32_t param_id, uint64_t buffer,
 		uint64_t length);
 int64_t opal_set_param(uint64_t token, uint32_t param_id, uint64_t buffer,
 		uint64_t length);
 int64_t opal_sensor_read(uint32_t sensor_hndl, int token, __be32 *sensor_data);
 /* Internal functions */
 extern int early_init_dt_scan_opal(unsigned long node, const char *uname,
 				   int depth, void *data);
 extern int early_init_dt_scan_recoverable_ranges(unsigned long node,
 				 const char *uname, int depth, void *data);
 extern int opal_get_chars(uint32_t vtermno, char *buf, int count);
 extern int opal_put_chars(uint32_t vtermno, const char *buf, int total_len);
 extern void hvc_opal_init_early(void);
 extern int opal_notifier_register(struct notifier_block *nb);
 extern int opal_notifier_unregister(struct notifier_block *nb);
 extern int opal_message_notifier_register(enum OpalMessageType msg_type,
 						struct notifier_block *nb);
 extern void opal_notifier_enable(void);
 extern void opal_notifier_disable(void);
 extern void opal_notifier_update_evt(uint64_t evt_mask, uint64_t evt_val);
 extern int __opal_async_get_token(void);
 extern int opal_async_get_token_interruptible(void);
 extern int __opal_async_release_token(int token);
 extern int opal_async_release_token(int token);
 extern int opal_async_wait_response(uint64_t token, struct opal_msg *msg);
 extern int opal_get_sensor_data(u32 sensor_hndl, u32 *sensor_data);
 struct rtc_time;
 extern int opal_set_rtc_time(struct rtc_time *tm);
 extern void opal_get_rtc_time(struct rtc_time *tm);
 extern unsigned long opal_get_boot_time(void);
 extern void opal_nvram_init(void);
 extern void opal_flash_init(void);
 extern int opal_elog_init(void);
 extern void opal_platform_dump_init(void);
 extern void opal_sys_param_init(void);
 extern void opal_msglog_init(void);
 extern int opal_machine_check(struct pt_regs *regs);
 extern bool opal_mce_check_early_recovery(struct pt_regs *regs);
 extern void opal_shutdown(void);
 extern int opal_resync_timebase(void);
 extern void opal_lpc_init(void);
+struct opal_sg_list *opal_vmalloc_to_sg_list(void *vmalloc_addr,
+					     unsigned long vmalloc_size);
+void opal_free_sg_list(struct opal_sg_list *sg);
 #endif /* __ASSEMBLY__ */
 #endif /* __OPAL_H */

arch/powerpc/platforms/powernv/opal-dump.c

Diff comments View file @ 3441f04

 /*
  * PowerNV OPAL Dump Interface
  *
  * Copyright 2013,2014 IBM Corp.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version
  * 2 of the License, or (at your option) any later version.
  */
 #include <linux/kobject.h>
 #include <linux/mm.h>
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
 #include <linux/pagemap.h>
 #include <linux/delay.h>
 #include <asm/opal.h>
 #define DUMP_TYPE_FSP	0x01
 struct dump_obj {
 	struct kobject  kobj;
 	struct bin_attribute dump_attr;
 	uint32_t	id;  /* becomes object name */
 	uint32_t	type;
 	uint32_t	size;
 	char		*buffer;
 };
 #define to_dump_obj(x) container_of(x, struct dump_obj, kobj)
 struct dump_attribute {
 	struct attribute attr;
 	ssize_t (*show)(struct dump_obj *dump, struct dump_attribute *attr,
 			char *buf);
 	ssize_t (*store)(struct dump_obj *dump, struct dump_attribute *attr,
 			 const char *buf, size_t count);
 };
 #define to_dump_attr(x) container_of(x, struct dump_attribute, attr)
 static ssize_t dump_id_show(struct dump_obj *dump_obj,
 			    struct dump_attribute *attr,
 			    char *buf)
 {
 	return sprintf(buf, "0x%x\n", dump_obj->id);
 }
 static const char* dump_type_to_string(uint32_t type)
 {
 	switch (type) {
 	case 0x01: return "SP Dump";
 	case 0x02: return "System/Platform Dump";
 	case 0x03: return "SMA Dump";
 	default: return "unknown";
 	}
 }
 static ssize_t dump_type_show(struct dump_obj *dump_obj,
 			      struct dump_attribute *attr,
 			      char *buf)
 {
 	return sprintf(buf, "0x%x %s\n", dump_obj->type,
 		       dump_type_to_string(dump_obj->type));
 }
 static ssize_t dump_ack_show(struct dump_obj *dump_obj,
 			     struct dump_attribute *attr,
 			     char *buf)
 {
 	return sprintf(buf, "ack - acknowledge dump\n");
 }
 /*
  * Send acknowledgement to OPAL
  */
 static int64_t dump_send_ack(uint32_t dump_id)
 {
 	int rc;
 	rc = opal_dump_ack(dump_id);
 	if (rc)
 		pr_warn("%s: Failed to send ack to Dump ID 0x%x (%d)\n",
 			__func__, dump_id, rc);
 	return rc;
 }
 static ssize_t dump_ack_store(struct dump_obj *dump_obj,
 			      struct dump_attribute *attr,
 			      const char *buf,
 			      size_t count)
 {
 	dump_send_ack(dump_obj->id);
 	sysfs_remove_file_self(&dump_obj->kobj, &attr->attr);
 	kobject_put(&dump_obj->kobj);
 	return count;
 }
 /* Attributes of a dump
  * The binary attribute of the dump itself is dynamic
  * due to the dynamic size of the dump
  */
 static struct dump_attribute id_attribute =
 	__ATTR(id, 0666, dump_id_show, NULL);
 static struct dump_attribute type_attribute =
 	__ATTR(type, 0666, dump_type_show, NULL);
 static struct dump_attribute ack_attribute =
 	__ATTR(acknowledge, 0660, dump_ack_show, dump_ack_store);
 static ssize_t init_dump_show(struct dump_obj *dump_obj,
 			      struct dump_attribute *attr,
 			      char *buf)
 {
 	return sprintf(buf, "1 - initiate dump\n");
 }
 static int64_t dump_fips_init(uint8_t type)
 {
 	int rc;
 	rc = opal_dump_init(type);
 	if (rc)
 		pr_warn("%s: Failed to initiate FipS dump (%d)\n",
 			__func__, rc);
 	return rc;
 }
 static ssize_t init_dump_store(struct dump_obj *dump_obj,
 			       struct dump_attribute *attr,
 			       const char *buf,
 			       size_t count)
 {
 	dump_fips_init(DUMP_TYPE_FSP);
 	pr_info("%s: Initiated FSP dump\n", __func__);
 	return count;
 }
 static struct dump_attribute initiate_attribute =
 	__ATTR(initiate_dump, 0600, init_dump_show, init_dump_store);
 static struct attribute *initiate_attrs[] = {
 	&initiate_attribute.attr,
 	NULL,
 };
 static struct attribute_group initiate_attr_group = {
 	.attrs = initiate_attrs,
 };
 static struct kset *dump_kset;
 static ssize_t dump_attr_show(struct kobject *kobj,
 			      struct attribute *attr,
 			      char *buf)
 {
 	struct dump_attribute *attribute;
 	struct dump_obj *dump;
 	attribute = to_dump_attr(attr);
 	dump = to_dump_obj(kobj);
 	if (!attribute->show)
 		return -EIO;
 	return attribute->show(dump, attribute, buf);
 }
 static ssize_t dump_attr_store(struct kobject *kobj,
 			       struct attribute *attr,
 			       const char *buf, size_t len)
 {
 	struct dump_attribute *attribute;
 	struct dump_obj *dump;
 	attribute = to_dump_attr(attr);
 	dump = to_dump_obj(kobj);
 	if (!attribute->store)
 		return -EIO;
 	return attribute->store(dump, attribute, buf, len);
 }
 static const struct sysfs_ops dump_sysfs_ops = {
 	.show = dump_attr_show,
 	.store = dump_attr_store,
 };
 static void dump_release(struct kobject *kobj)
 {
 	struct dump_obj *dump;
 	dump = to_dump_obj(kobj);
 	vfree(dump->buffer);
 	kfree(dump);
 }
 static struct attribute *dump_default_attrs[] = {
 	&id_attribute.attr,
 	&type_attribute.attr,
 	&ack_attribute.attr,
 	NULL,
 };
 static struct kobj_type dump_ktype = {
 	.sysfs_ops = &dump_sysfs_ops,
 	.release = &dump_release,
 	.default_attrs = dump_default_attrs,
 };
-static void free_dump_sg_list(struct opal_sg_list *list)
-{
-	struct opal_sg_list *sg1;
-	while (list) {
-		sg1 = list->next;
-		kfree(list);
-		list = sg1;
-	}
-	list = NULL;
-}
-static struct opal_sg_list *dump_data_to_sglist(struct dump_obj *dump)
-{
-	struct opal_sg_list *sg1, *list = NULL;
-	void *addr;
-	int64_t size;
-	addr = dump->buffer;
-	size = dump->size;
-	sg1 = kzalloc(PAGE_SIZE, GFP_KERNEL);
-	if (!sg1)
-		goto nomem;
-	list = sg1;
-	sg1->num_entries = 0;
-	while (size > 0) {
-		/* Translate virtual address to physical address */
-		sg1->entry[sg1->num_entries].data =
-			(void *)(vmalloc_to_pfn(addr) << PAGE_SHIFT);
-		if (size > PAGE_SIZE)
-			sg1->entry[sg1->num_entries].length = PAGE_SIZE;
-		else
-			sg1->entry[sg1->num_entries].length = size;
-		sg1->num_entries++;
-		if (sg1->num_entries >= SG_ENTRIES_PER_NODE) {
-			sg1->next = kzalloc(PAGE_SIZE, GFP_KERNEL);
-			if (!sg1->next)
-				goto nomem;
-			sg1 = sg1->next;
-			sg1->num_entries = 0;
-		}
-		addr += PAGE_SIZE;
-		size -= PAGE_SIZE;
-	}
-	return list;
-nomem:
-	pr_err("%s : Failed to allocate memory\n", __func__);
-	free_dump_sg_list(list);
-	return NULL;
-}
-static void sglist_to_phy_addr(struct opal_sg_list *list)
-{
-	struct opal_sg_list *sg, *next;
-	for (sg = list; sg; sg = next) {
-		next = sg->next;
-		/* Don't translate NULL pointer for last entry */
-		if (sg->next)
-			sg->next = (struct opal_sg_list *)__pa(sg->next);
-		else
-			sg->next = NULL;
-		/* Convert num_entries to length */
-		sg->num_entries =
-			sg->num_entries * sizeof(struct opal_sg_entry) + 16;
-	}
-}
 static int64_t dump_read_info(uint32_t *id, uint32_t *size, uint32_t *type)
 {
 	int rc;
 	*type = 0xffffffff;
 	rc = opal_dump_info2(id, size, type);
 	if (rc == OPAL_PARAMETER)
 		rc = opal_dump_info(id, size);
 	if (rc)
 		pr_warn("%s: Failed to get dump info (%d)\n",
 			__func__, rc);
 	return rc;
 }
 static int64_t dump_read_data(struct dump_obj *dump)
 {
 	struct opal_sg_list *list;
 	uint64_t addr;
 	int64_t rc;
 	/* Allocate memory */
 	dump->buffer = vzalloc(PAGE_ALIGN(dump->size));
 	if (!dump->buffer) {
 		pr_err("%s : Failed to allocate memory\n", __func__);
 		rc = -ENOMEM;
 		goto out;
 	}
 	/* Generate SG list */
-	list = dump_data_to_sglist(dump);
+	list = opal_vmalloc_to_sg_list(dump->buffer, dump->size);
 	if (!list) {
 		rc = -ENOMEM;
 		goto out;
 	}
-	/* Translate sg list addr to real address */
-	sglist_to_phy_addr(list);
 	/* First entry address */
 	addr = __pa(list);
 	/* Fetch data */
 	rc = OPAL_BUSY_EVENT;
 	while (rc == OPAL_BUSY || rc == OPAL_BUSY_EVENT) {
 		rc = opal_dump_read(dump->id, addr);
 		if (rc == OPAL_BUSY_EVENT) {
 			opal_poll_events(NULL);
 			msleep(20);
 		}
 	}
 	if (rc != OPAL_SUCCESS && rc != OPAL_PARTIAL)
 		pr_warn("%s: Extract dump failed for ID 0x%x\n",
 			__func__, dump->id);
 	/* Free SG list */
-	free_dump_sg_list(list);
+	opal_free_sg_list(list);
 out:
 	return rc;
 }
 static ssize_t dump_attr_read(struct file *filep, struct kobject *kobj,
 			      struct bin_attribute *bin_attr,
 			      char *buffer, loff_t pos, size_t count)
 {
 	ssize_t rc;
 	struct dump_obj *dump = to_dump_obj(kobj);
 	if (!dump->buffer) {
 		rc = dump_read_data(dump);
 		if (rc != OPAL_SUCCESS && rc != OPAL_PARTIAL) {
 			vfree(dump->buffer);
 			dump->buffer = NULL;
 			return -EIO;
 		}
 		if (rc == OPAL_PARTIAL) {
 			/* On a partial read, we just return EIO
 			 * and rely on userspace to ask us to try
 			 * again.
 			 */
 			pr_info("%s: Platform dump partially read.ID = 0x%x\n",
 				__func__, dump->id);
 			return -EIO;
 		}
 	}
 	memcpy(buffer, dump->buffer + pos, count);
 	/* You may think we could free the dump buffer now and retrieve
 	 * it again later if needed, but due to current firmware limitation,
 	 * that's not the case. So, once read into userspace once,
 	 * we keep the dump around until it's acknowledged by userspace.
 	 */
 	return count;
 }
 static struct dump_obj *create_dump_obj(uint32_t id, size_t size,
 					uint32_t type)
 {
 	struct dump_obj *dump;
 	int rc;
 	dump = kzalloc(sizeof(*dump), GFP_KERNEL);
 	if (!dump)
 		return NULL;
 	dump->kobj.kset = dump_kset;
 	kobject_init(&dump->kobj, &dump_ktype);
 	sysfs_bin_attr_init(&dump->dump_attr);
 	dump->dump_attr.attr.name = "dump";
 	dump->dump_attr.attr.mode = 0400;
 	dump->dump_attr.size = size;
 	dump->dump_attr.read = dump_attr_read;
 	dump->id = id;
 	dump->size = size;
 	dump->type = type;
 	rc = kobject_add(&dump->kobj, NULL, "0x%x-0x%x", type, id);
 	if (rc) {
 		kobject_put(&dump->kobj);
 		return NULL;
 	}
 	rc = sysfs_create_bin_file(&dump->kobj, &dump->dump_attr);
 	if (rc) {
 		kobject_put(&dump->kobj);
 		return NULL;
 	}
 	pr_info("%s: New platform dump. ID = 0x%x Size %u\n",
 		__func__, dump->id, dump->size);
 	kobject_uevent(&dump->kobj, KOBJ_ADD);
 	return dump;
 }
 static int process_dump(void)
 {
 	int rc;
 	uint32_t dump_id, dump_size, dump_type;
 	struct dump_obj *dump;
 	char name[22];
 	rc = dump_read_info(&dump_id, &dump_size, &dump_type);
 	if (rc != OPAL_SUCCESS)
 		return rc;
 	sprintf(name, "0x%x-0x%x", dump_type, dump_id);
 	/* we may get notified twice, let's handle
 	 * that gracefully and not create two conflicting
 	 * entries.
 	 */
 	if (kset_find_obj(dump_kset, name))
 		return 0;
 	dump = create_dump_obj(dump_id, dump_size, dump_type);
 	if (!dump)
 		return -1;
 	return 0;
 }
 static void dump_work_fn(struct work_struct *work)
 {
 	process_dump();
 }
 static DECLARE_WORK(dump_work, dump_work_fn);
 static void schedule_process_dump(void)
 {
 	schedule_work(&dump_work);
 }
 /*
  * New dump available notification
  *
  * Once we get notification, we add sysfs entries for it.
  * We only fetch the dump on demand, and create sysfs asynchronously.
  */
 static int dump_event(struct notifier_block *nb,
 		      unsigned long events, void *change)
 {
 	if (events & OPAL_EVENT_DUMP_AVAIL)
 		schedule_process_dump();
 	return 0;
 }
 static struct notifier_block dump_nb = {
 	.notifier_call  = dump_event,
 	.next           = NULL,
 	.priority       = 0
 };
 void __init opal_platform_dump_init(void)
 {
 	int rc;
 	dump_kset = kset_create_and_add("dump", NULL, opal_kobj);
 	if (!dump_kset) {
 		pr_warn("%s: Failed to create dump kset\n", __func__);
 		return;
 	}
 	rc = sysfs_create_group(&dump_kset->kobj, &initiate_attr_group);
 	if (rc) {
 		pr_warn("%s: Failed to create initiate dump attr group\n",
 			__func__);
 		kobject_put(&dump_kset->kobj);
 		return;
 	}
 	rc = opal_notifier_register(&dump_nb);
 	if (rc) {
 		pr_warn("%s: Can't register OPAL event notifier (%d)\n",
 			__func__, rc);
 		return;
 	}
 	opal_dump_resend_notification();
 }

arch/powerpc/platforms/powernv/opal-flash.c

Diff comments View file @ 3441f04

 /*
  * PowerNV OPAL Firmware Update Interface
  *
  * Copyright 2013 IBM Corp.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version
  * 2 of the License, or (at your option) any later version.
  */
 #define DEBUG
 #include <linux/kernel.h>
 #include <linux/reboot.h>
 #include <linux/init.h>
 #include <linux/kobject.h>
 #include <linux/sysfs.h>
 #include <linux/slab.h>
 #include <linux/mm.h>
 #include <linux/vmalloc.h>
 #include <linux/pagemap.h>
 #include <asm/opal.h>
 /* FLASH status codes */
 #define FLASH_NO_OP		-1099	/* No operation initiated by user */
 #define FLASH_NO_AUTH		-9002	/* Not a service authority partition */
 /* Validate image status values */
 #define VALIDATE_IMG_READY	-1001	/* Image ready for validation */
 #define VALIDATE_IMG_INCOMPLETE	-1002	/* User copied < VALIDATE_BUF_SIZE */
 /* Manage image status values */
 #define MANAGE_ACTIVE_ERR	-9001	/* Cannot overwrite active img */
 /* Flash image status values */
 #define FLASH_IMG_READY		0	/* Img ready for flash on reboot */
 #define FLASH_INVALID_IMG	-1003	/* Flash image shorter than expected */
 #define FLASH_IMG_NULL_DATA	-1004	/* Bad data in sg list entry */
 #define FLASH_IMG_BAD_LEN	-1005	/* Bad length in sg list entry */
 /* Manage operation tokens */
 #define FLASH_REJECT_TMP_SIDE	0	/* Reject temporary fw image */
 #define FLASH_COMMIT_TMP_SIDE	1	/* Commit temporary fw image */
 /* Update tokens */
 #define FLASH_UPDATE_CANCEL	0	/* Cancel update request */
 #define FLASH_UPDATE_INIT	1	/* Initiate update */
 /* Validate image update result tokens */
 #define VALIDATE_TMP_UPDATE	0     /* T side will be updated */
 #define VALIDATE_FLASH_AUTH	1     /* Partition does not have authority */
 #define VALIDATE_INVALID_IMG	2     /* Candidate image is not valid */
 #define VALIDATE_CUR_UNKNOWN	3     /* Current fixpack level is unknown */
 /*
  * Current T side will be committed to P side before being replace with new
  * image, and the new image is downlevel from current image
  */
 #define VALIDATE_TMP_COMMIT_DL	4
 /*
  * Current T side will be committed to P side before being replaced with new
  * image
  */
 #define VALIDATE_TMP_COMMIT	5
 /*
  * T side will be updated with a downlevel image
  */
 #define VALIDATE_TMP_UPDATE_DL	6
 /*
  * The candidate image's release date is later than the system's firmware
  * service entitlement date - service warranty period has expired
  */
 #define VALIDATE_OUT_OF_WRNTY	7
 /* Validate buffer size */
 #define VALIDATE_BUF_SIZE	4096
 /* XXX: Assume candidate image size is <= 1GB */
 #define MAX_IMAGE_SIZE	0x40000000
-/* Flash sg list version */
-#define SG_LIST_VERSION (1UL)
 /* Image status */
 enum {
 	IMAGE_INVALID,
 	IMAGE_LOADING,
 	IMAGE_READY,
 };
 /* Candidate image data */
 struct image_data_t {
 	int		status;
 	void		*data;
 	uint32_t	size;
 };
 /* Candidate image header */
 struct image_header_t {
 	uint16_t	magic;
 	uint16_t	version;
 	uint32_t	size;
 };
 struct validate_flash_t {
 	int		status;		/* Return status */
 	void		*buf;		/* Candidate image buffer */
 	uint32_t	buf_size;	/* Image size */
 	uint32_t	result;		/* Update results token */
 };
 struct manage_flash_t {
 	int status;		/* Return status */
 };
 struct update_flash_t {
 	int status;		/* Return status */
 };
 static struct image_header_t	image_header;
 static struct image_data_t	image_data;
 static struct validate_flash_t	validate_flash_data;
 static struct manage_flash_t	manage_flash_data;
 static struct update_flash_t	update_flash_data;
 static DEFINE_MUTEX(image_data_mutex);
 /*
  * Validate candidate image
  */
 static inline void opal_flash_validate(void)
 {
 	long ret;
 	void *buf = validate_flash_data.buf;
 	__be32 size, result;
 	ret = opal_validate_flash(__pa(buf), &size, &result);
 	validate_flash_data.status = ret;
 	validate_flash_data.buf_size = be32_to_cpu(size);
 	validate_flash_data.result = be32_to_cpu(result);
 }
 /*
  * Validate output format:
  *     validate result token
  *     current image version details
  *     new image version details
  */
 static ssize_t validate_show(struct kobject *kobj,
 			     struct kobj_attribute *attr, char *buf)
 {
 	struct validate_flash_t *args_buf = &validate_flash_data;
 	int len;
 	/* Candidate image is not validated */
 	if (args_buf->status < VALIDATE_TMP_UPDATE) {
 		len = sprintf(buf, "%d\n", args_buf->status);
 		goto out;
 	}
 	/* Result token */
 	len = sprintf(buf, "%d\n", args_buf->result);
 	/* Current and candidate image version details */
 	if ((args_buf->result != VALIDATE_TMP_UPDATE) &&
 	    (args_buf->result < VALIDATE_CUR_UNKNOWN))
 		goto out;
 	if (args_buf->buf_size > (VALIDATE_BUF_SIZE - len)) {
 		memcpy(buf + len, args_buf->buf, VALIDATE_BUF_SIZE - len);
 		len = VALIDATE_BUF_SIZE;
 	} else {
 		memcpy(buf + len, args_buf->buf, args_buf->buf_size);
 		len += args_buf->buf_size;
 	}
 out:
 	/* Set status to default */
 	args_buf->status = FLASH_NO_OP;
 	return len;
 }
 /*
  * Validate candidate firmware image
  *
  * Note:
  *   We are only interested in first 4K bytes of the
  *   candidate image.
  */
 static ssize_t validate_store(struct kobject *kobj,
 			      struct kobj_attribute *attr,
 			      const char *buf, size_t count)
 {
 	struct validate_flash_t *args_buf = &validate_flash_data;
 	if (buf[0] != '1')
 		return -EINVAL;
 	mutex_lock(&image_data_mutex);
 	if (image_data.status != IMAGE_READY ||
 	    image_data.size < VALIDATE_BUF_SIZE) {
 		args_buf->result = VALIDATE_INVALID_IMG;
 		args_buf->status = VALIDATE_IMG_INCOMPLETE;
 		goto out;
 	}
 	/* Copy first 4k bytes of candidate image */
 	memcpy(args_buf->buf, image_data.data, VALIDATE_BUF_SIZE);
 	args_buf->status = VALIDATE_IMG_READY;
 	args_buf->buf_size = VALIDATE_BUF_SIZE;
 	/* Validate candidate image */
 	opal_flash_validate();
 out:
 	mutex_unlock(&image_data_mutex);
 	return count;
 }
 /*
  * Manage flash routine
  */
 static inline void opal_flash_manage(uint8_t op)
 {
 	struct manage_flash_t *const args_buf = &manage_flash_data;
 	args_buf->status = opal_manage_flash(op);
 }
 /*
  * Show manage flash status
  */
 static ssize_t manage_show(struct kobject *kobj,
 			   struct kobj_attribute *attr, char *buf)
 {
 	struct manage_flash_t *const args_buf = &manage_flash_data;
 	int rc;
 	rc = sprintf(buf, "%d\n", args_buf->status);
 	/* Set status to default*/
 	args_buf->status = FLASH_NO_OP;
 	return rc;
 }
 /*
  * Manage operations:
  *   0 - Reject
  *   1 - Commit
  */
 static ssize_t manage_store(struct kobject *kobj,
 			    struct kobj_attribute *attr,
 			    const char *buf, size_t count)
 {
 	uint8_t op;
 	switch (buf[0]) {
 	case '0':
 		op = FLASH_REJECT_TMP_SIDE;
 		break;
 	case '1':
 		op = FLASH_COMMIT_TMP_SIDE;
 		break;
 	default:
 		return -EINVAL;
 	}
 	/* commit/reject temporary image */
 	opal_flash_manage(op);
 	return count;
 }
 /*
- * Free sg list
- */
-static void free_sg_list(struct opal_sg_list *list)
-{
-	struct opal_sg_list *sg1;
-	while (list) {
-		sg1 = list->next;
-		kfree(list);
-		list = sg1;
-	}
-	list = NULL;
-}
-/*
- * Build candidate image scatter gather list
- *
- * list format:
- *   -----------------------------------
- *  |  VER (8) | Entry length in bytes  |
- *   -----------------------------------
- *  |  Pointer to next entry            |
- *   -----------------------------------
- *  |  Address of memory area 1         |
- *   -----------------------------------
- *  |  Length of memory area 1          |
- *   -----------------------------------
- *  |   .........                       |
- *   -----------------------------------
- *  |   .........                       |
- *   -----------------------------------
- *  |  Address of memory area N         |
- *   -----------------------------------
- *  |  Length of memory area N          |
- *   -----------------------------------
- */
-static struct opal_sg_list *image_data_to_sglist(void)
-{
-	struct opal_sg_list *sg1, *list = NULL;
-	void *addr;
-	int size;
-	addr = image_data.data;
-	size = image_data.size;
-	sg1 = kzalloc(PAGE_SIZE, GFP_KERNEL);
-	if (!sg1)
-		return NULL;
-	list = sg1;
-	sg1->num_entries = 0;
-	while (size > 0) {
-		/* Translate virtual address to physical address */
-		sg1->entry[sg1->num_entries].data =
-			(void *)(vmalloc_to_pfn(addr) << PAGE_SHIFT);
-		if (size > PAGE_SIZE)
-			sg1->entry[sg1->num_entries].length = PAGE_SIZE;
-		else
-			sg1->entry[sg1->num_entries].length = size;
-		sg1->num_entries++;
-		if (sg1->num_entries >= SG_ENTRIES_PER_NODE) {
-			sg1->next = kzalloc(PAGE_SIZE, GFP_KERNEL);
-			if (!sg1->next) {
-				pr_err("%s : Failed to allocate memory\n",
-				       __func__);
-				goto nomem;
-			}
-			sg1 = sg1->next;
-			sg1->num_entries = 0;
-		}
-		addr += PAGE_SIZE;
-		size -= PAGE_SIZE;
-	}
-	return list;
-nomem:
-	free_sg_list(list);
-	return NULL;
-}
-/*
  * OPAL update flash
  */
 static int opal_flash_update(int op)
 {
-	struct opal_sg_list *sg, *list, *next;
+	struct opal_sg_list *list;
 	unsigned long addr;
 	int64_t rc = OPAL_PARAMETER;
 	if (op == FLASH_UPDATE_CANCEL) {
 		pr_alert("FLASH: Image update cancelled\n");
 		addr = '\0';
 		goto flash;
 	}
-	list = image_data_to_sglist();
+	list = opal_vmalloc_to_sg_list(image_data.data, image_data.size);
 	if (!list)
 		goto invalid_img;
 	/* First entry address */
 	addr = __pa(list);
-	/* Translate sg list address to absolute */
-	for (sg = list; sg; sg = next) {
-		next = sg->next;
-		/* Don't translate NULL pointer for last entry */
-		if (sg->next)
-			sg->next = (struct opal_sg_list *)__pa(sg->next);
-		else
-			sg->next = NULL;
-		/*
-		 * Convert num_entries to version/length format
-		 * to satisfy OPAL.
-		 */
-		sg->num_entries = (SG_LIST_VERSION << 56) |
-			(sg->num_entries * sizeof(struct opal_sg_entry) + 16);
-	}
 	pr_alert("FLASH: Image is %u bytes\n", image_data.size);
 	pr_alert("FLASH: Image update requested\n");
 	pr_alert("FLASH: Image will be updated during system reboot\n");
 	pr_alert("FLASH: This will take several minutes. Do not power off!\n");
 flash:
 	rc = opal_update_flash(addr);
 invalid_img:
 	return rc;
 }
 /*
  * Show candidate image status
  */
 static ssize_t update_show(struct kobject *kobj,
 			   struct kobj_attribute *attr, char *buf)
 {
 	struct update_flash_t *const args_buf = &update_flash_data;
 	return sprintf(buf, "%d\n", args_buf->status);
 }
 /*
  * Set update image flag
  *  1 - Flash new image
  *  0 - Cancel flash request
  */
 static ssize_t update_store(struct kobject *kobj,
 			    struct kobj_attribute *attr,
 			    const char *buf, size_t count)
 {
 	struct update_flash_t *const args_buf = &update_flash_data;
 	int rc = count;
 	mutex_lock(&image_data_mutex);
 	switch (buf[0]) {
 	case '0':
 		if (args_buf->status == FLASH_IMG_READY)
 			opal_flash_update(FLASH_UPDATE_CANCEL);
 		args_buf->status = FLASH_NO_OP;
 		break;
 	case '1':
 		/* Image is loaded? */
 		if (image_data.status == IMAGE_READY)
 			args_buf->status =
 				opal_flash_update(FLASH_UPDATE_INIT);
 		else
 			args_buf->status = FLASH_INVALID_IMG;
 		break;
 	default:
 		rc = -EINVAL;
 	}
 	mutex_unlock(&image_data_mutex);
 	return rc;
 }
 /*
  * Free image buffer
  */
 static void free_image_buf(void)
 {
 	void *addr;
 	int size;
 	addr = image_data.data;
 	size = PAGE_ALIGN(image_data.size);
 	while (size > 0) {
 		ClearPageReserved(vmalloc_to_page(addr));
 		addr += PAGE_SIZE;
 		size -= PAGE_SIZE;
 	}
 	vfree(image_data.data);
 	image_data.data = NULL;
 	image_data.status = IMAGE_INVALID;
 }
 /*
  * Allocate image buffer.
  */
 static int alloc_image_buf(char *buffer, size_t count)
 {
 	void *addr;
 	int size;
 	if (count < sizeof(struct image_header_t)) {
 		pr_warn("FLASH: Invalid candidate image\n");
 		return -EINVAL;
 	}
 	memcpy(&image_header, (void *)buffer, sizeof(struct image_header_t));
 	image_data.size = be32_to_cpu(image_header.size);
 	pr_debug("FLASH: Candidate image size = %u\n", image_data.size);
 	if (image_data.size > MAX_IMAGE_SIZE) {
 		pr_warn("FLASH: Too large image\n");
 		return -EINVAL;
 	}
 	if (image_data.size < VALIDATE_BUF_SIZE) {
 		pr_warn("FLASH: Image is shorter than expected\n");
 		return -EINVAL;
 	}
 	image_data.data = vzalloc(PAGE_ALIGN(image_data.size));
 	if (!image_data.data) {
 		pr_err("%s : Failed to allocate memory\n", __func__);
 		return -ENOMEM;
 	}
 	/* Pin memory */
 	addr = image_data.data;
 	size = PAGE_ALIGN(image_data.size);
 	while (size > 0) {
 		SetPageReserved(vmalloc_to_page(addr));
 		addr += PAGE_SIZE;
 		size -= PAGE_SIZE;
 	}
 	image_data.status = IMAGE_LOADING;
 	return 0;
 }
 /*
  * Copy candidate image
  *
  * Parse candidate image header to get total image size
  * and pre-allocate required memory.
  */
 static ssize_t image_data_write(struct file *filp, struct kobject *kobj,
 				struct bin_attribute *bin_attr,
 				char *buffer, loff_t pos, size_t count)
 {
 	int rc;
 	mutex_lock(&image_data_mutex);
 	/* New image ? */
 	if (pos == 0) {
 		/* Free memory, if already allocated */
 		if (image_data.data)
 			free_image_buf();
 		/* Cancel outstanding image update request */
 		if (update_flash_data.status == FLASH_IMG_READY)
 			opal_flash_update(FLASH_UPDATE_CANCEL);
 		/* Allocate memory */
 		rc = alloc_image_buf(buffer, count);
 		if (rc)
 			goto out;
 	}
 	if (image_data.status != IMAGE_LOADING) {
 		rc = -ENOMEM;
 		goto out;
 	}
 	if ((pos + count) > image_data.size) {
 		rc = -EINVAL;
 		goto out;
 	}
 	memcpy(image_data.data + pos, (void *)buffer, count);
 	rc = count;
 	/* Set image status */
 	if ((pos + count) == image_data.size) {
 		pr_debug("FLASH: Candidate image loaded....\n");
 		image_data.status = IMAGE_READY;
 	}
 out:
 	mutex_unlock(&image_data_mutex);
 	return rc;
 }
 /*
  * sysfs interface :
  *  OPAL uses below sysfs files for code update.
  *  We create these files under /sys/firmware/opal.
  *
  *   image		: Interface to load candidate firmware image
  *   validate_flash	: Validate firmware image
  *   manage_flash	: Commit/Reject firmware image
  *   update_flash	: Flash new firmware image
  *
  */
 static struct bin_attribute image_data_attr = {
 	.attr = {.name = "image", .mode = 0200},
 	.size = MAX_IMAGE_SIZE,	/* Limit image size */
 	.write = image_data_write,
 };
 static struct kobj_attribute validate_attribute =
 	__ATTR(validate_flash, 0600, validate_show, validate_store);
 static struct kobj_attribute manage_attribute =
 	__ATTR(manage_flash, 0600, manage_show, manage_store);
 static struct kobj_attribute update_attribute =
 	__ATTR(update_flash, 0600, update_show, update_store);
 static struct attribute *image_op_attrs[] = {
 	&validate_attribute.attr,
 	&manage_attribute.attr,
 	&update_attribute.attr,
 	NULL	/* need to NULL terminate the list of attributes */
 };
 static struct attribute_group image_op_attr_group = {
 	.attrs = image_op_attrs,
 };
 void __init opal_flash_init(void)
 {
 	int ret;
 	/* Allocate validate image buffer */
 	validate_flash_data.buf = kzalloc(VALIDATE_BUF_SIZE, GFP_KERNEL);
 	if (!validate_flash_data.buf) {
 		pr_err("%s : Failed to allocate memory\n", __func__);
 		return;
 	}
 	/* Make sure /sys/firmware/opal directory is created */
 	if (!opal_kobj) {
 		pr_warn("FLASH: opal kobject is not available\n");
 		goto nokobj;
 	}
 	/* Create the sysfs files */
 	ret = sysfs_create_group(opal_kobj, &image_op_attr_group);
 	if (ret) {
 		pr_warn("FLASH: Failed to create sysfs files\n");
 		goto nokobj;
 	}
 	ret = sysfs_create_bin_file(opal_kobj, &image_data_attr);
 	if (ret) {
 		pr_warn("FLASH: Failed to create sysfs files\n");
 		goto nosysfs_file;
 	}
 	/* Set default status */
 	validate_flash_data.status = FLASH_NO_OP;
 	manage_flash_data.status = FLASH_NO_OP;
 	update_flash_data.status = FLASH_NO_OP;
 	image_data.status = IMAGE_INVALID;
 	return;
 nosysfs_file:
 	sysfs_remove_group(opal_kobj, &image_op_attr_group);
 nokobj:
 	kfree(validate_flash_data.buf);
 	return;
 }

arch/powerpc/platforms/powernv/opal.c

Diff comments View file @ 3441f04

 /*
  * PowerNV OPAL high level interfaces
  *
  * Copyright 2011 IBM Corp.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version
  * 2 of the License, or (at your option) any later version.
  */
 #undef DEBUG
 #include <linux/types.h>
 #include <linux/of.h>
 #include <linux/of_fdt.h>
 #include <linux/of_platform.h>
 #include <linux/interrupt.h>
 #include <linux/notifier.h>
 #include <linux/slab.h>
 #include <linux/sched.h>
 #include <linux/kobject.h>
 #include <linux/delay.h>
 #include <linux/memblock.h>
 #include <asm/opal.h>
 #include <asm/firmware.h>
 #include <asm/mce.h>
 #include "powernv.h"
 /* /sys/firmware/opal */
 struct kobject *opal_kobj;
 struct opal {
 	u64 base;
 	u64 entry;
 	u64 size;
 } opal;
 struct mcheck_recoverable_range {
 	u64 start_addr;
 	u64 end_addr;
 	u64 recover_addr;
 };
 static struct mcheck_recoverable_range *mc_recoverable_range;
 static int mc_recoverable_range_len;
 struct device_node *opal_node;
 static DEFINE_SPINLOCK(opal_write_lock);
 extern u64 opal_mc_secondary_handler[];
 static unsigned int *opal_irqs;
 static unsigned int opal_irq_count;
 static ATOMIC_NOTIFIER_HEAD(opal_notifier_head);
 static struct atomic_notifier_head opal_msg_notifier_head[OPAL_MSG_TYPE_MAX];
 static DEFINE_SPINLOCK(opal_notifier_lock);
 static uint64_t last_notified_mask = 0x0ul;
 static atomic_t opal_notifier_hold = ATOMIC_INIT(0);
 int __init early_init_dt_scan_opal(unsigned long node,
 				   const char *uname, int depth, void *data)
 {
 	const void *basep, *entryp, *sizep;
 	unsigned long basesz, entrysz, runtimesz;
 	if (depth != 1 || strcmp(uname, "ibm,opal") != 0)
 		return 0;
 	basep  = of_get_flat_dt_prop(node, "opal-base-address", &basesz);
 	entryp = of_get_flat_dt_prop(node, "opal-entry-address", &entrysz);
 	sizep = of_get_flat_dt_prop(node, "opal-runtime-size", &runtimesz);
 	if (!basep || !entryp || !sizep)
 		return 1;
 	opal.base = of_read_number(basep, basesz/4);
 	opal.entry = of_read_number(entryp, entrysz/4);
 	opal.size = of_read_number(sizep, runtimesz/4);
 	pr_debug("OPAL Base  = 0x%llx (basep=%p basesz=%ld)\n",
 		 opal.base, basep, basesz);
 	pr_debug("OPAL Entry = 0x%llx (entryp=%p basesz=%ld)\n",
 		 opal.entry, entryp, entrysz);
 	pr_debug("OPAL Entry = 0x%llx (sizep=%p runtimesz=%ld)\n",
 		 opal.size, sizep, runtimesz);
 	powerpc_firmware_features |= FW_FEATURE_OPAL;
 	if (of_flat_dt_is_compatible(node, "ibm,opal-v3")) {
 		powerpc_firmware_features |= FW_FEATURE_OPALv2;
 		powerpc_firmware_features |= FW_FEATURE_OPALv3;
 		printk("OPAL V3 detected !\n");
 	} else if (of_flat_dt_is_compatible(node, "ibm,opal-v2")) {
 		powerpc_firmware_features |= FW_FEATURE_OPALv2;
 		printk("OPAL V2 detected !\n");
 	} else {
 		printk("OPAL V1 detected !\n");
 	}
 	return 1;
 }
 int __init early_init_dt_scan_recoverable_ranges(unsigned long node,
 				   const char *uname, int depth, void *data)
 {
 	unsigned long i, psize, size;
 	const __be32 *prop;
 	if (depth != 1 || strcmp(uname, "ibm,opal") != 0)
 		return 0;
 	prop = of_get_flat_dt_prop(node, "mcheck-recoverable-ranges", &psize);
 	if (!prop)
 		return 1;
 	pr_debug("Found machine check recoverable ranges.\n");
 	/*
 	 * Calculate number of available entries.
 	 *
 	 * Each recoverable address range entry is (start address, len,
 	 * recovery address), 2 cells each for start and recovery address,
 	 * 1 cell for len, totalling 5 cells per entry.
 	 */
 	mc_recoverable_range_len = psize / (sizeof(*prop) * 5);
 	/* Sanity check */
 	if (!mc_recoverable_range_len)
 		return 1;
 	/* Size required to hold all the entries. */
 	size = mc_recoverable_range_len *
 			sizeof(struct mcheck_recoverable_range);
 	/*
 	 * Allocate a buffer to hold the MC recoverable ranges. We would be
 	 * accessing them in real mode, hence it needs to be within
 	 * RMO region.
 	 */
 	mc_recoverable_range =__va(memblock_alloc_base(size, __alignof__(u64),
 							ppc64_rma_size));
 	memset(mc_recoverable_range, 0, size);
 	for (i = 0; i < mc_recoverable_range_len; i++) {
 		mc_recoverable_range[i].start_addr =
 					of_read_number(prop + (i * 5) + 0, 2);
 		mc_recoverable_range[i].end_addr =
 					mc_recoverable_range[i].start_addr +
 					of_read_number(prop + (i * 5) + 2, 1);
 		mc_recoverable_range[i].recover_addr =
 					of_read_number(prop + (i * 5) + 3, 2);
 		pr_debug("Machine check recoverable range: %llx..%llx: %llx\n",
 				mc_recoverable_range[i].start_addr,
 				mc_recoverable_range[i].end_addr,
 				mc_recoverable_range[i].recover_addr);
 	}
 	return 1;
 }
 static int __init opal_register_exception_handlers(void)
 {
 #ifdef __BIG_ENDIAN__
 	u64 glue;
 	if (!(powerpc_firmware_features & FW_FEATURE_OPAL))
 		return -ENODEV;
 	/* Hookup some exception handlers except machine check. We use the
 	 * fwnmi area at 0x7000 to provide the glue space to OPAL
 	 */
 	glue = 0x7000;
 	opal_register_exception_handler(OPAL_HYPERVISOR_MAINTENANCE_HANDLER,
 					0, glue);
 	glue += 128;
 	opal_register_exception_handler(OPAL_SOFTPATCH_HANDLER, 0, glue);
 #endif
 	return 0;
 }
 early_initcall(opal_register_exception_handlers);
 int opal_notifier_register(struct notifier_block *nb)
 {
 	if (!nb) {
 		pr_warning("%s: Invalid argument (%p)\n",
 			   __func__, nb);
 		return -EINVAL;
 	}
 	atomic_notifier_chain_register(&opal_notifier_head, nb);
 	return 0;
 }
 EXPORT_SYMBOL_GPL(opal_notifier_register);
 int opal_notifier_unregister(struct notifier_block *nb)
 {
 	if (!nb) {
 		pr_warning("%s: Invalid argument (%p)\n",
 			   __func__, nb);
 		return -EINVAL;
 	}
 	atomic_notifier_chain_unregister(&opal_notifier_head, nb);
 	return 0;
 }
 EXPORT_SYMBOL_GPL(opal_notifier_unregister);
 static void opal_do_notifier(uint64_t events)
 {
 	unsigned long flags;
 	uint64_t changed_mask;
 	if (atomic_read(&opal_notifier_hold))
 		return;
 	spin_lock_irqsave(&opal_notifier_lock, flags);
 	changed_mask = last_notified_mask ^ events;
 	last_notified_mask = events;
 	spin_unlock_irqrestore(&opal_notifier_lock, flags);
 	/*
 	 * We feed with the event bits and changed bits for
 	 * enough information to the callback.
 	 */
 	atomic_notifier_call_chain(&opal_notifier_head,
 				   events, (void *)changed_mask);
 }
 void opal_notifier_update_evt(uint64_t evt_mask,
 			      uint64_t evt_val)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&opal_notifier_lock, flags);
 	last_notified_mask &= ~evt_mask;
 	last_notified_mask |= evt_val;
 	spin_unlock_irqrestore(&opal_notifier_lock, flags);
 }
 void opal_notifier_enable(void)
 {
 	int64_t rc;
 	__be64 evt = 0;
 	atomic_set(&opal_notifier_hold, 0);
 	/* Process pending events */
 	rc = opal_poll_events(&evt);
 	if (rc == OPAL_SUCCESS && evt)
 		opal_do_notifier(be64_to_cpu(evt));
 }
 void opal_notifier_disable(void)
 {
 	atomic_set(&opal_notifier_hold, 1);
 }
 /*
  * Opal message notifier based on message type. Allow subscribers to get
  * notified for specific messgae type.
  */
 int opal_message_notifier_register(enum OpalMessageType msg_type,
 					struct notifier_block *nb)
 {
 	if (!nb) {
 		pr_warning("%s: Invalid argument (%p)\n",
 			   __func__, nb);
 		return -EINVAL;
 	}
 	if (msg_type > OPAL_MSG_TYPE_MAX) {
 		pr_warning("%s: Invalid message type argument (%d)\n",
 			   __func__, msg_type);
 		return -EINVAL;
 	}
 	return atomic_notifier_chain_register(
 				&opal_msg_notifier_head[msg_type], nb);
 }
 static void opal_message_do_notify(uint32_t msg_type, void *msg)
 {
 	/* notify subscribers */
 	atomic_notifier_call_chain(&opal_msg_notifier_head[msg_type],
 					msg_type, msg);
 }
 static void opal_handle_message(void)
 {
 	s64 ret;
 	/*
 	 * TODO: pre-allocate a message buffer depending on opal-msg-size
 	 * value in /proc/device-tree.
 	 */
 	static struct opal_msg msg;
 	u32 type;
 	ret = opal_get_msg(__pa(&msg), sizeof(msg));
 	/* No opal message pending. */
 	if (ret == OPAL_RESOURCE)
 		return;
 	/* check for errors. */
 	if (ret) {
 		pr_warning("%s: Failed to retrive opal message, err=%lld\n",
 				__func__, ret);
 		return;
 	}
 	type = be32_to_cpu(msg.msg_type);
 	/* Sanity check */
 	if (type > OPAL_MSG_TYPE_MAX) {
 		pr_warning("%s: Unknown message type: %u\n", __func__, type);
 		return;
 	}
 	opal_message_do_notify(type, (void *)&msg);
 }
 static int opal_message_notify(struct notifier_block *nb,
 			  unsigned long events, void *change)
 {
 	if (events & OPAL_EVENT_MSG_PENDING)
 		opal_handle_message();
 	return 0;
 }
 static struct notifier_block opal_message_nb = {
 	.notifier_call	= opal_message_notify,
 	.next		= NULL,
 	.priority	= 0,
 };
 static int __init opal_message_init(void)
 {
 	int ret, i;
 	for (i = 0; i < OPAL_MSG_TYPE_MAX; i++)
 		ATOMIC_INIT_NOTIFIER_HEAD(&opal_msg_notifier_head[i]);
 	ret = opal_notifier_register(&opal_message_nb);
 	if (ret) {
 		pr_err("%s: Can't register OPAL event notifier (%d)\n",
 		       __func__, ret);
 		return ret;
 	}
 	return 0;
 }
 early_initcall(opal_message_init);
 int opal_get_chars(uint32_t vtermno, char *buf, int count)
 {
 	s64 rc;
 	__be64 evt, len;
 	if (!opal.entry)
 		return -ENODEV;
 	opal_poll_events(&evt);
 	if ((be64_to_cpu(evt) & OPAL_EVENT_CONSOLE_INPUT) == 0)
 		return 0;
 	len = cpu_to_be64(count);
 	rc = opal_console_read(vtermno, &len, buf);
 	if (rc == OPAL_SUCCESS)
 		return be64_to_cpu(len);
 	return 0;
 }
 int opal_put_chars(uint32_t vtermno, const char *data, int total_len)
 {
 	int written = 0;
 	__be64 olen;
 	s64 len, rc;
 	unsigned long flags;
 	__be64 evt;
 	if (!opal.entry)
 		return -ENODEV;
 	/* We want put_chars to be atomic to avoid mangling of hvsi
 	 * packets. To do that, we first test for room and return
 	 * -EAGAIN if there isn't enough.
 	 *
 	 * Unfortunately, opal_console_write_buffer_space() doesn't
 	 * appear to work on opal v1, so we just assume there is
 	 * enough room and be done with it
 	 */
 	spin_lock_irqsave(&opal_write_lock, flags);
 	if (firmware_has_feature(FW_FEATURE_OPALv2)) {
 		rc = opal_console_write_buffer_space(vtermno, &olen);
 		len = be64_to_cpu(olen);
 		if (rc || len < total_len) {
 			spin_unlock_irqrestore(&opal_write_lock, flags);
 			/* Closed -> drop characters */
 			if (rc)
 				return total_len;
 			opal_poll_events(NULL);
 			return -EAGAIN;
 		}
 	}
 	/* We still try to handle partial completions, though they
 	 * should no longer happen.
 	 */
 	rc = OPAL_BUSY;
 	while(total_len > 0 && (rc == OPAL_BUSY ||
 				rc == OPAL_BUSY_EVENT || rc == OPAL_SUCCESS)) {
 		olen = cpu_to_be64(total_len);
 		rc = opal_console_write(vtermno, &olen, data);
 		len = be64_to_cpu(olen);
 		/* Closed or other error drop */
 		if (rc != OPAL_SUCCESS && rc != OPAL_BUSY &&
 		    rc != OPAL_BUSY_EVENT) {
 			written = total_len;
 			break;
 		}
 		if (rc == OPAL_SUCCESS) {
 			total_len -= len;
 			data += len;
 			written += len;
 		}
 		/* This is a bit nasty but we need that for the console to
 		 * flush when there aren't any interrupts. We will clean
 		 * things a bit later to limit that to synchronous path
 		 * such as the kernel console and xmon/udbg
 		 */
 		do
 			opal_poll_events(&evt);
 		while(rc == OPAL_SUCCESS &&
 			(be64_to_cpu(evt) & OPAL_EVENT_CONSOLE_OUTPUT));
 	}
 	spin_unlock_irqrestore(&opal_write_lock, flags);
 	return written;
 }
 static int opal_recover_mce(struct pt_regs *regs,
 					struct machine_check_event *evt)
 {
 	int recovered = 0;
 	uint64_t ea = get_mce_fault_addr(evt);
 	if (!(regs->msr & MSR_RI)) {
 		/* If MSR_RI isn't set, we cannot recover */
 		recovered = 0;
 	} else if (evt->disposition == MCE_DISPOSITION_RECOVERED) {
 		/* Platform corrected itself */
 		recovered = 1;
 	} else if (ea && !is_kernel_addr(ea)) {
 		/*
 		 * Faulting address is not in kernel text. We should be fine.
 		 * We need to find which process uses this address.
 		 * For now, kill the task if we have received exception when
 		 * in userspace.
 		 *
 		 * TODO: Queue up this address for hwpoisioning later.
 		 */
 		if (user_mode(regs) && !is_global_init(current)) {
 			_exception(SIGBUS, regs, BUS_MCEERR_AR, regs->nip);
 			recovered = 1;
 		} else
 			recovered = 0;
 	} else if (user_mode(regs) && !is_global_init(current) &&
 		evt->severity == MCE_SEV_ERROR_SYNC) {
 		/*
 		 * If we have received a synchronous error when in userspace
 		 * kill the task.
 		 */
 		_exception(SIGBUS, regs, BUS_MCEERR_AR, regs->nip);
 		recovered = 1;
 	}
 	return recovered;
 }
 int opal_machine_check(struct pt_regs *regs)
 {
 	struct machine_check_event evt;
 	if (!get_mce_event(&evt, MCE_EVENT_RELEASE))
 		return 0;
 	/* Print things out */
 	if (evt.version != MCE_V1) {
 		pr_err("Machine Check Exception, Unknown event version %d !\n",
 		       evt.version);
 		return 0;
 	}
 	machine_check_print_event_info(&evt);
 	if (opal_recover_mce(regs, &evt))
 		return 1;
 	return 0;
 }
 static uint64_t find_recovery_address(uint64_t nip)
 {
 	int i;
 	for (i = 0; i < mc_recoverable_range_len; i++)
 		if ((nip >= mc_recoverable_range[i].start_addr) &&
 		    (nip < mc_recoverable_range[i].end_addr))
 		    return mc_recoverable_range[i].recover_addr;
 	return 0;
 }
 bool opal_mce_check_early_recovery(struct pt_regs *regs)
 {
 	uint64_t recover_addr = 0;
 	if (!opal.base || !opal.size)
 		goto out;
 	if ((regs->nip >= opal.base) &&
 			(regs->nip <= (opal.base + opal.size)))
 		recover_addr = find_recovery_address(regs->nip);
 	/*
 	 * Setup regs->nip to rfi into fixup address.
 	 */
 	if (recover_addr)
 		regs->nip = recover_addr;
 out:
 	return !!recover_addr;
 }
 static irqreturn_t opal_interrupt(int irq, void *data)
 {
 	__be64 events;
 	opal_handle_interrupt(virq_to_hw(irq), &events);
 	opal_do_notifier(be64_to_cpu(events));
 	return IRQ_HANDLED;
 }
 static int opal_sysfs_init(void)
 {
 	opal_kobj = kobject_create_and_add("opal", firmware_kobj);
 	if (!opal_kobj) {
 		pr_warn("kobject_create_and_add opal failed\n");
 		return -ENOMEM;
 	}
 	return 0;
 }
 static int __init opal_init(void)
 {
 	struct device_node *np, *consoles;
 	const __be32 *irqs;
 	int rc, i, irqlen;
 	opal_node = of_find_node_by_path("/ibm,opal");
 	if (!opal_node) {
 		pr_warn("opal: Node not found\n");
 		return -ENODEV;
 	}
 	/* Register OPAL consoles if any ports */
 	if (firmware_has_feature(FW_FEATURE_OPALv2))
 		consoles = of_find_node_by_path("/ibm,opal/consoles");
 	else
 		consoles = of_node_get(opal_node);
 	if (consoles) {
 		for_each_child_of_node(consoles, np) {
 			if (strcmp(np->name, "serial"))
 				continue;
 			of_platform_device_create(np, NULL, NULL);
 		}
 		of_node_put(consoles);
 	}
 	/* Find all OPAL interrupts and request them */
 	irqs = of_get_property(opal_node, "opal-interrupts", &irqlen);
 	pr_debug("opal: Found %d interrupts reserved for OPAL\n",
 		 irqs ? (irqlen / 4) : 0);
 	opal_irq_count = irqlen / 4;
 	opal_irqs = kzalloc(opal_irq_count * sizeof(unsigned int), GFP_KERNEL);
 	for (i = 0; irqs && i < (irqlen / 4); i++, irqs++) {
 		unsigned int hwirq = be32_to_cpup(irqs);
 		unsigned int irq = irq_create_mapping(NULL, hwirq);
 		if (irq == NO_IRQ) {
 			pr_warning("opal: Failed to map irq 0x%x\n", hwirq);
 			continue;
 		}
 		rc = request_irq(irq, opal_interrupt, 0, "opal", NULL);
 		if (rc)
 			pr_warning("opal: Error %d requesting irq %d"
 				   " (0x%x)\n", rc, irq, hwirq);
 		opal_irqs[i] = irq;
 	}
 	/* Create "opal" kobject under /sys/firmware */
 	rc = opal_sysfs_init();
 	if (rc == 0) {
 		/* Setup error log interface */
 		rc = opal_elog_init();
 		/* Setup code update interface */
 		opal_flash_init();
 		/* Setup platform dump extract interface */
 		opal_platform_dump_init();
 		/* Setup system parameters interface */
 		opal_sys_param_init();
 		/* Setup message log interface. */
 		opal_msglog_init();
 	}
 	return 0;
 }
 subsys_initcall(opal_init);
 void opal_shutdown(void)
 {
 	unsigned int i;
 	long rc = OPAL_BUSY;
 	/* First free interrupts, which will also mask them */
 	for (i = 0; i < opal_irq_count; i++) {
 		if (opal_irqs[i])
 			free_irq(opal_irqs[i], NULL);
 		opal_irqs[i] = 0;
 	}
 	/*
 	 * Then sync with OPAL which ensure anything that can
 	 * potentially write to our memory has completed such
 	 * as an ongoing dump retrieval
 	 */
 	while (rc == OPAL_BUSY || rc == OPAL_BUSY_EVENT) {
 		rc = opal_sync_host_reboot();
 		if (rc == OPAL_BUSY)
 			opal_poll_events(NULL);
 		else
 			mdelay(10);
 	}
 }
 /* Export this so that test modules can use it */
 EXPORT_SYMBOL_GPL(opal_invalid_call);
+/* Convert a region of vmalloc memory to an opal sg list */
+struct opal_sg_list *opal_vmalloc_to_sg_list(void *vmalloc_addr,
+					     unsigned long vmalloc_size)
+{
+	struct opal_sg_list *sg, *first = NULL;
+	unsigned long i = 0;
+	sg = kzalloc(PAGE_SIZE, GFP_KERNEL);
+	if (!sg)
+		goto nomem;
+	first = sg;
+	while (vmalloc_size > 0) {
+		uint64_t data = vmalloc_to_pfn(vmalloc_addr) << PAGE_SHIFT;
+		uint64_t length = min(vmalloc_size, PAGE_SIZE);
+		sg->entry[i].data = cpu_to_be64(data);
+		sg->entry[i].length = cpu_to_be64(length);
+		i++;
+		if (i >= SG_ENTRIES_PER_NODE) {
+			struct opal_sg_list *next;
+			next = kzalloc(PAGE_SIZE, GFP_KERNEL);
+			if (!next)
+				goto nomem;
+			sg->length = cpu_to_be64(
+					i * sizeof(struct opal_sg_entry) + 16);
+			i = 0;
+			sg->next = cpu_to_be64(__pa(next));
+			sg = next;
+		}
+		vmalloc_addr += length;
+		vmalloc_size -= length;
+	}
+	sg->length = cpu_to_be64(i * sizeof(struct opal_sg_entry) + 16);
+	return first;
+nomem:
+	pr_err("%s : Failed to allocate memory\n", __func__);
+	opal_free_sg_list(first);
+	return NULL;
+}
+void opal_free_sg_list(struct opal_sg_list *sg)
+{
+	while (sg) {
+		uint64_t next = be64_to_cpu(sg->next);
+		kfree(sg);
+		if (next)
+			sg = __va(next);
+		else
+			sg = NULL;
+	}
+}