include: Introduce required header files for SMEM driver

/* Copyright (c) 2012-2015, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and

 * only version 2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 */

#ifndef _IPC_LOGGING_H

#define _IPC_LOGGING_H

#include <linux/types.h>

#define MAX_MSG_SIZE 255

enum {

	TSV_TYPE_MSG_START = 1,

	TSV_TYPE_SKB = TSV_TYPE_MSG_START,

	TSV_TYPE_STRING,

	TSV_TYPE_MSG_END = TSV_TYPE_STRING,

};

struct tsv_header {

	unsigned char type;

	unsigned char size; /* size of data field */

};

struct encode_context {

	struct tsv_header hdr;

	char buff[MAX_MSG_SIZE];

	int offset;

};

struct decode_context {

	int output_format;      /* 0 = debugfs */

	char *buff;             /* output buffer */

	int size;               /* size of output buffer */

};

#if defined(CONFIG_IPC_LOGGING)

/*

 * ipc_log_context_create: Create a debug log context

 *                         Should not be called from atomic context

 *

 * @max_num_pages: Number of pages of logging space required (max. 10)

 * @mod_name     : Name of the directory entry under DEBUGFS

 * @user_version : Version number of user-defined message formats

 *

 * returns context id on success, NULL on failure

 */

void *ipc_log_context_create(int max_num_pages, const char *modname,

		uint16_t user_version);

/*

 * msg_encode_start: Start encoding a log message

 *

 * @ectxt: Temporary storage to hold the encoded message

 * @type:  Root event type defined by the module which is logging

 */

void msg_encode_start(struct encode_context *ectxt, uint32_t type);

/*

 * tsv_timestamp_write: Writes the current timestamp count

 *

 * @ectxt: Context initialized by calling msg_encode_start()

 */

int tsv_timestamp_write(struct encode_context *ectxt);

/*

 * tsv_qtimer_write: Writes the current QTimer timestamp count

 *

 * @ectxt: Context initialized by calling msg_encode_start()

 */

int tsv_qtimer_write(struct encode_context *ectxt);

/*

 * tsv_pointer_write: Writes a data pointer

 *

 * @ectxt:   Context initialized by calling msg_encode_start()

 * @pointer: Pointer value to write

 */

int tsv_pointer_write(struct encode_context *ectxt, void *pointer);

/*

 * tsv_int32_write: Writes a 32-bit integer value

 *

 * @ectxt: Context initialized by calling msg_encode_start()

 * @n:     Integer to write

 */

int tsv_int32_write(struct encode_context *ectxt, int32_t n);

/*

 * tsv_int32_write: Writes a 32-bit integer value

 *

 * @ectxt: Context initialized by calling msg_encode_start()

 * @n:     Integer to write

 */

int tsv_byte_array_write(struct encode_context *ectxt,

			 void *data, int data_size);

/*

 * msg_encode_end: Complete the message encode process

 *

 * @ectxt: Temporary storage which holds the encoded message

 */

void msg_encode_end(struct encode_context *ectxt);

/*

 * msg_encode_end: Complete the message encode process

 *

 * @ectxt: Temporary storage which holds the encoded message

 */

void ipc_log_write(void *ctxt, struct encode_context *ectxt);

/*

 * ipc_log_string: Helper function to log a string

 *

 * @ilctxt: Debug Log Context created using ipc_log_context_create()

 * @fmt:    Data specified using format specifiers

 */

int ipc_log_string(void *ilctxt, const char *fmt, ...) __printf(2, 3);

/**

 * ipc_log_extract - Reads and deserializes log

 *

 * @ilctxt:  logging context

 * @buff:    buffer to receive the data

 * @size:    size of the buffer

 * @returns: 0 if no data read; >0 number of bytes read; < 0 error

 *

 * If no data is available to be read, then the ilctxt::read_avail

 * completion is reinitialized.  This allows clients to block

 * until new log data is save.

 */

int ipc_log_extract(void *ilctxt, char *buff, int size);

/*

 * Print a string to decode context.

 * @dctxt   Decode context

 * @args   printf args

 */

#define IPC_SPRINTF_DECODE(dctxt, args...) \

do { \

	int i; \

	i = scnprintf(dctxt->buff, dctxt->size, args); \

	dctxt->buff += i; \

	dctxt->size -= i; \

} while (0)

/*

 * tsv_timestamp_read: Reads a timestamp

 *

 * @ectxt:  Context retrieved by reading from log space

 * @dctxt:  Temporary storage to hold the decoded message

 * @format: Output format while dumping through DEBUGFS

 */

void tsv_timestamp_read(struct encode_context *ectxt,

			struct decode_context *dctxt, const char *format);

/*

 * tsv_qtimer_read: Reads a QTimer timestamp

 *

 * @ectxt:  Context retrieved by reading from log space

 * @dctxt:  Temporary storage to hold the decoded message

 * @format: Output format while dumping through DEBUGFS

 */

void tsv_qtimer_read(struct encode_context *ectxt,

		     struct decode_context *dctxt, const char *format);

/*

 * tsv_pointer_read: Reads a data pointer

 *

 * @ectxt:  Context retrieved by reading from log space

 * @dctxt:  Temporary storage to hold the decoded message

 * @format: Output format while dumping through DEBUGFS

 */

void tsv_pointer_read(struct encode_context *ectxt,

		      struct decode_context *dctxt, const char *format);

/*

 * tsv_int32_read: Reads a 32-bit integer value

 *

 * @ectxt:  Context retrieved by reading from log space

 * @dctxt:  Temporary storage to hold the decoded message

 * @format: Output format while dumping through DEBUGFS

 */

int32_t tsv_int32_read(struct encode_context *ectxt,

		       struct decode_context *dctxt, const char *format);

/*

 * tsv_int32_read: Reads a 32-bit integer value

 *

 * @ectxt:  Context retrieved by reading from log space

 * @dctxt:  Temporary storage to hold the decoded message

 * @format: Output format while dumping through DEBUGFS

 */

void tsv_byte_array_read(struct encode_context *ectxt,

			 struct decode_context *dctxt, const char *format);

/*

 * add_deserialization_func: Register a deserialization function to

 *                           to unpack the subevents of a main event

 *

 * @ctxt: Debug log context to which the deserialization function has

 *        to be registered

 * @type: Main/Root event, defined by the module which is logging, to

 *        which this deserialization function has to be registered.

 * @dfune: Deserialization function to be registered

 *

 * return 0 on success, -ve value on FAILURE

 */

int add_deserialization_func(void *ctxt, int type,

			void (*dfunc)(struct encode_context *,

				      struct decode_context *));

/*

 * ipc_log_context_destroy: Destroy debug log context

 *

 * @ctxt: debug log context created by calling ipc_log_context_create API.

 */

int ipc_log_context_destroy(void *ctxt);

#else

static inline void *ipc_log_context_create(int max_num_pages,

	const char *modname, uint16_t user_version)

{ return NULL; }

static inline void msg_encode_start(struct encode_context *ectxt,

	uint32_t type) { }

static inline int tsv_timestamp_write(struct encode_context *ectxt)

{ return -EINVAL; }

static inline int tsv_qtimer_write(struct encode_context *ectxt)

{ return -EINVAL; }

static inline int tsv_pointer_write(struct encode_context *ectxt, void *pointer)

{ return -EINVAL; }

static inline int tsv_int32_write(struct encode_context *ectxt, int32_t n)

{ return -EINVAL; }

static inline int tsv_byte_array_write(struct encode_context *ectxt,

			 void *data, int data_size)

{ return -EINVAL; }

static inline void msg_encode_end(struct encode_context *ectxt) { }

static inline void ipc_log_write(void *ctxt, struct encode_context *ectxt) { }

static inline int ipc_log_string(void *ilctxt, const char *fmt, ...)

{ return -EINVAL; }

static inline int ipc_log_extract(void *ilctxt, char *buff, int size)

{ return -EINVAL; }

#define IPC_SPRINTF_DECODE(dctxt, args...) do { } while (0)

static inline void tsv_timestamp_read(struct encode_context *ectxt,

			struct decode_context *dctxt, const char *format) { }

static inline void tsv_qtimer_read(struct encode_context *ectxt,

			struct decode_context *dctxt, const char *format) { }

static inline void tsv_pointer_read(struct encode_context *ectxt,

		      struct decode_context *dctxt, const char *format) { }

static inline int32_t tsv_int32_read(struct encode_context *ectxt,

		       struct decode_context *dctxt, const char *format)

{ return 0; }

static inline void tsv_byte_array_read(struct encode_context *ectxt,

			 struct decode_context *dctxt, const char *format) { }

static inline int add_deserialization_func(void *ctxt, int type,

			void (*dfunc)(struct encode_context *,

				      struct decode_context *))

{ return 0; }

static inline int ipc_log_context_destroy(void *ctxt)

{ return 0; }

#endif

#endif

/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and

 * only version 2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 */

#ifndef _RAMDUMP_HEADER

#define _RAMDUMP_HEADER

struct device;

struct ramdump_segment {

	unsigned long address;

	void *v_address;

	unsigned long size;

};

#ifdef CONFIG_MSM_SUBSYSTEM_RESTART

extern void *create_ramdump_device(const char *dev_name, struct device *parent);

extern void destroy_ramdump_device(void *dev);

extern int do_ramdump(void *handle, struct ramdump_segment *segments,

		int nsegments);

extern int do_elf_ramdump(void *handle, struct ramdump_segment *segments,

		int nsegments);

#else

static inline void *create_ramdump_device(const char *dev_name,

		struct device *parent)

{

	return NULL;

}

static inline void destroy_ramdump_device(void *dev)

{

}

static inline int do_ramdump(void *handle, struct ramdump_segment *segments,

		int nsegments)

{

	return -ENODEV;

}

static inline int do_elf_ramdump(void *handle, struct ramdump_segment *segments,

		int nsegments)

{

	return -ENODEV;

}

#endif /* CONFIG_MSM_SUBSYSTEM_RESTART */

#endif

/* Copyright (c) 2011, 2013 - 2014, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and

 * only version 2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 *

 * Subsystem restart notifier API header

 *

 */

#ifndef _SUBSYS_NOTIFIER_H

#define _SUBSYS_NOTIFIER_H

#include <linux/notifier.h>

enum subsys_notif_type {

	SUBSYS_BEFORE_SHUTDOWN,

	SUBSYS_AFTER_SHUTDOWN,

	SUBSYS_BEFORE_POWERUP,

	SUBSYS_AFTER_POWERUP,

	SUBSYS_RAMDUMP_NOTIFICATION,

	SUBSYS_POWERUP_FAILURE,

	SUBSYS_PROXY_VOTE,

	SUBSYS_PROXY_UNVOTE,

	SUBSYS_SOC_RESET,

	SUBSYS_NOTIF_TYPE_COUNT

};

#if defined(CONFIG_MSM_SUBSYSTEM_RESTART)

/* Use the subsys_notif_register_notifier API to register for notifications for

 * a particular subsystem. This API will return a handle that can be used to

 * un-reg for notifications using the subsys_notif_unregister_notifier API by

 * passing in that handle as an argument.

 *

 * On receiving a notification, the second (unsigned long) argument of the

 * notifier callback will contain the notification type, and the third (void *)

 * argument will contain the handle that was returned by

 * subsys_notif_register_notifier.

 */

void *subsys_notif_register_notifier(

			const char *subsys_name, struct notifier_block *nb);

int subsys_notif_unregister_notifier(void *subsys_handle,

				struct notifier_block *nb);

/* Use the subsys_notif_init_subsys API to initialize the notifier chains form

 * a particular subsystem. This API will return a handle that can be used to

 * queue notifications using the subsys_notif_queue_notification API by passing

 * in that handle as an argument.

 */

void *subsys_notif_add_subsys(const char *);

int subsys_notif_queue_notification(void *subsys_handle,

					enum subsys_notif_type notif_type,

					void *data);

#else

static inline void *subsys_notif_register_notifier(

			const char *subsys_name, struct notifier_block *nb)

{

	return NULL;

}

static inline int subsys_notif_unregister_notifier(void *subsys_handle,

					struct notifier_block *nb)

{

	return 0;

}

static inline void *subsys_notif_add_subsys(const char *subsys_name)

{

	return NULL;

}

static inline int subsys_notif_queue_notification(void *subsys_handle,

					enum subsys_notif_type notif_type,

					void *data)

{

	return 0;

}

#endif /* CONFIG_MSM_SUBSYSTEM_RESTART */

#endif

/* Copyright (c) 2014-2015, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and

 * only version 2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 */

#ifndef __SUBSYS_RESTART_H

#define __SUBSYS_RESTART_H

#include <linux/spinlock.h>

#include <linux/interrupt.h>

struct subsys_device;

enum {

	RESET_SOC = 0,

	RESET_SUBSYS_COUPLED,

	RESET_LEVEL_MAX

};

struct device;

struct module;

/**

 * struct subsys_desc - subsystem descriptor

 * @name: name of subsystem

 * @fw_name: firmware name

 * @depends_on: subsystem this subsystem depends on to operate

 * @dev: parent device

 * @owner: module the descriptor belongs to

 * @shutdown: Stop a subsystem

 * @powerup: Start a subsystem

 * @crash_shutdown: Shutdown a subsystem when the system crashes (can't sleep)

 * @ramdump: Collect a ramdump of the subsystem

 * @free_memory: Free the memory associated with this subsystem

 * @is_not_loadable: Indicate if subsystem firmware is not loadable via pil

 * framework

 * @no_auth: Set if subsystem does not rely on PIL to authenticate and bring

 * it out of reset

 * @ssctl_instance_id: Instance id used to connect with SSCTL service

 * @sysmon_pid:	pdev id that sysmon is probed with for the subsystem

 * @sysmon_shutdown_ret: Return value for the call to sysmon_send_shutdown

 * @system_debug: If "set", triggers a device restart when the

 * subsystem's wdog bite handler is invoked.

 * @edge: GLINK logical name of the subsystem

 */

struct subsys_desc {

	const char *name;

	char fw_name[256];

	const char *depends_on;

	struct device *dev;

	struct module *owner;

	int (*shutdown)(const struct subsys_desc *desc, bool force_stop);

	int (*powerup)(const struct subsys_desc *desc);

	void (*crash_shutdown)(const struct subsys_desc *desc);

	int (*ramdump)(int, const struct subsys_desc *desc);

	void (*free_memory)(const struct subsys_desc *desc);

	irqreturn_t (*err_fatal_handler) (int irq, void *dev_id);

	irqreturn_t (*stop_ack_handler) (int irq, void *dev_id);

	irqreturn_t (*wdog_bite_handler) (int irq, void *dev_id);

	int is_not_loadable;

	int err_fatal_gpio;

	unsigned int err_fatal_irq;

	unsigned int err_ready_irq;

	unsigned int stop_ack_irq;

	unsigned int wdog_bite_irq;

	int force_stop_gpio;

	int ramdump_disable_gpio;

	int shutdown_ack_gpio;

	int ramdump_disable;

	bool no_auth;

	int ssctl_instance_id;

	u32 sysmon_pid;

	int sysmon_shutdown_ret;

	bool system_debug;

	const char *edge;

};

/**

 * struct notif_data - additional notif information

 * @crashed: indicates if subsystem has crashed

 * @enable_ramdump: ramdumps disabled if set to 0

 * @enable_mini_ramdumps: enable flag for minimized critical-memory-only

 * ramdumps

 * @no_auth: set if subsystem does not use PIL to bring it out of reset

 * @pdev: subsystem platform device pointer

 */

struct notif_data {

	bool crashed;

	int enable_ramdump;

	int enable_mini_ramdumps;

	bool no_auth;

	struct platform_device *pdev;

};

#if defined(CONFIG_MSM_SUBSYSTEM_RESTART)

extern int subsys_get_restart_level(struct subsys_device *dev);

extern int subsystem_restart_dev(struct subsys_device *dev);

extern int subsystem_restart(const char *name);

extern int subsystem_crashed(const char *name);

extern void *subsystem_get(const char *name);

extern void *subsystem_get_with_fwname(const char *name, const char *fw_name);

extern void subsystem_put(void *subsystem);

extern struct subsys_device *subsys_register(struct subsys_desc *desc);

extern void subsys_unregister(struct subsys_device *dev);

extern void subsys_default_online(struct subsys_device *dev);

extern void subsys_set_crash_status(struct subsys_device *dev, bool crashed);

extern bool subsys_get_crash_status(struct subsys_device *dev);

void notify_proxy_vote(struct device *device);

void notify_proxy_unvote(struct device *device);

extern int wait_for_shutdown_ack(struct subsys_desc *desc);

#else

static inline int subsys_get_restart_level(struct subsys_device *dev)

{

	return 0;

}

static inline int subsystem_restart_dev(struct subsys_device *dev)

{

	return 0;

}

static inline int subsystem_restart(const char *name)

{

	return 0;

}

static inline int subsystem_crashed(const char *name)

{

	return 0;

}

static inline void *subsystem_get(const char *name)

{

	return NULL;

}

static inline void *subsystem_get_with_fwname(const char *name,

				const char *fw_name) {

	return NULL;

}

static inline void subsystem_put(void *subsystem) { }

static inline

struct subsys_device *subsys_register(struct subsys_desc *desc)

{

	return NULL;

}

static inline void subsys_unregister(struct subsys_device *dev) { }

static inline void subsys_default_online(struct subsys_device *dev) { }

static inline

void subsys_set_crash_status(struct subsys_device *dev, bool crashed) { }

static inline bool subsys_get_crash_status(struct subsys_device *dev)

{

	return false;

}

static inline void notify_proxy_vote(struct device *device) { }

static inline void notify_proxy_unvote(struct device *device) { }

static inline int wait_for_shutdown_ack(struct subsys_desc *desc)

{

	return -ENOSYS;

}

#endif /* CONFIG_MSM_SUBSYSTEM_RESTART */

#endif