Merge remote-tracking branch 'quic/msm-4.14' into dev/msm-4.14-display

Introduction

============

Resource Power Manager (RPM)

RPM is a dedicated hardware engine for managing shared SoC resources,

which includes buses, clocks, power rails, etc.  The goal of RPM is

to achieve the maximum power savings while satisfying the SoC's

operational and performance requirements.  RPM accepts resource

requests from multiple RPM masters.  It arbitrates and aggregates the

requests, and configures the shared resources.  The RPM masters are

the application processor, the modem processor, as well as some

hardware accelerators.

The RPM driver provides an API for interacting with RPM.  Kernel code

calls the RPM driver to request RPM-managed, shared resources.

Kernel code can also register with the driver for RPM notifications,

which are sent when the status of shared resources change.

Hardware description

====================

RPM exposes a separate region of registers to each of the RPM masters.

In general, each register represents some shared resource(s).  At a

very basic level, a master requests resources by writing to the

registers, then generating an interrupt to RPM.  RPM processes the

request, writes acknowledgment to the registers, then generates an

interrupt to the master.

In addition to the master-specific regions, RPM also exposes a shared

region that contains the current status of the shared resources.  Only

RPM can write to the status region, but every master can read from it.

RPM contains internal logics that aggregate and arbitrate among

requests from the various RPM masters.  It interfaces with the PMIC,

the bus arbitration block, and the clock controller block in order to

configure the shared resources.

Software description

====================

The RPM driver encapsulates the low level RPM interactions, which

rely on reading/writing registers and generating/processing

interrupts, and provides a higher level synchronuous set/clear/get

interface.  Most functions take an array of id-value pairs.

The ids identify the RPM registers which would correspond to some

RPM resources, the values specify the new resource values.

The RPM driver synchronizes accesses to RPM.  It protects against

simultaneous accesses from multiple tasks, on SMP cores, in task

contexts, and in atomic contexts.

Design

======

Design goals:

- Encapsulate low level RPM interactions.

- Provide a synchronuous set/clear/get interface.

- Synchronize simultaneous software accesses to RPM.

Power Management

================

RPM is part of the power management architecture for MSM 8660.  RPM

manages shared system resources to lower system power.

SMP/multi-core

==============

The RPM driver uses mutex to synchronize client accesses among tasks.

It uses spinlocks to synchronize accesses from atomic contexts and

SMP cores.

Security

========

None.

Performance

===========

None.

Interface

=========

msm_rpm_get_status():

The function reads the shared status region and returns the current

resource values, which are the arbitrated/aggregated results across

all RPM masters.

msm_rpm_set():

The function makes a resource request to RPM.

msm_rpm_set_noirq():

The function is similar to msm_rpm_set() except that it must be

called with interrupts masked.  If possible, use msm_rpm_set()

instead, to maximize CPU throughput.

msm_rpm_clear():

The function makes a resource request to RPM to clear resource values.

Once the values are cleared, the resources revert back to their default

values for this RPM master.  RPM internally uses the default values as

the requests from this RPM master when arbitrating and aggregating with

requests from other RPM masters.

msm_rpm_clear_noirq():

The function is similar to msm_rpm_clear() except that it must be

called with interrupts masked.  If possible, use msm_rpm_clear()

instead, to maximize CPU throughput.

msm_rpm_register_notification():

The function registers for RPM notification.  When the specified

resources change their status on RPM, RPM sends out notifications

and the driver will "up" the semaphore in struct

msm_rpm_notification.

msm_rpm_unregister_notification():

The function unregisters a notification.

msm_rpm_init():

The function initializes the RPM driver with platform specific data.

Driver parameters

=================

None.

Config options

==============

MSM_RPM

Dependencies

============

None.

User space utilities

====================

None.

Other

=====

None.

Known issues

============

None.

To do

=====

None.

Bus Proxy Client Bindings

Bus proxy client provides means to cast proxy bandwidth votes during bootup

which is removed at the end of boot. This feature can be used in situations

where a shared resource can be scaled between several possible perfomance

levels and hardware requires that it be at a high level at the beginning of

boot before the client has probed and voted for required bandwidth.

Required properties:

- compatible:			Must be "qcom,bus-proxy-client".

Optional properties:

- qcom,msm-bus,name:		String representing the client-name.

- qcom,msm-bus,num-cases:	Total number of usecases.

- qcom,msm-bus,active-only:	Boolean context flag for requests in active or

				dual (active & sleep) contex.

- qcom,msm-bus,num-paths:	Total number of master-slave pairs.

- qcom,msm-bus,vectors-KBps:	Arrays of unsigned integers representing:

				master-id, slave-id, arbitrated bandwidth

				in KBps, instantaneous bandwidth in KBps.

Example:

	qcom,proxy-client {

		compatible = "qcom,bus-proxy-client";

		qcom,msm-bus,name = "proxy_client";

		qcom,msm-bus,num-cases = <3>;

		qcom,msm-bus,num-paths = <2>;

		qcom,msm-bus,active-only;

		qcom,msm-bus,vectors-KBps =

			<22 512 0 0>, <23 512 0 0>,

			<22 512 0 6400000>, <23 512 0 6400000>,

			<22 512 0 6400000>, <23 512 0 6400000>;

	};

Resource Power Manager(RPM)

RPM is a dedicated hardware engine for managing shared SoC resources,

which includes buses, clocks, power rails, etc.  The goal of RPM is

to achieve the maximum power savings while satisfying the SoC's

operational and performance requirements.  RPM accepts resource

requests from multiple RPM masters.  It arbitrates and aggregates the

requests, and configures the shared resources.  The RPM masters are

the application processor, the modem processor, as well as hardware

accelerators. The RPM driver communicates with the hardware engine using

SMD.

The devicetree representation of the SPM block should be:

Required properties

- compatible: "qcom,rpm-smd" or "qcom,rpm-glink"

- rpm-channel-name: The string corresponding to the channel name of the

			peripheral subsystem. Required for both smd and

			glink transports.

- rpm-channel-type: The interal SMD edge for this subsystem found in

			<soc/qcom/smd.h>

- qcom,glink-edge: Logical name of the remote subsystem. This is a required

			property when rpm-smd driver using glink as trasport.

Optional properties

- rpm-standalone: Allow RPM driver to run in standalone mode irrespective of RPM

			channel presence.

- reg: Contains the memory address at which rpm messaging format version is

  stored. If this field is not present, the target only supports v0 format.

Example:

	qcom,rpm-smd@68150 {

		compatible = "qcom,rpm-smd", "qcom,rpm-glink";

		reg = <0x68150 0x3200>;

		qcom,rpm-channel-name = "rpm_requests";

		qcom,rpm-channel-type = 15; /* SMD_APPS_RPM */

		qcom,glink-edge = "rpm";

	}

}

		BIT(3) : MHI bus driver pre-allocate buffer for this channel.

		If set, clients not allowed to queue buffers. Valid only for DL

		direction.

		BIT(4) : MHI host driver to automatically start channels once

		mhi device driver probe is complete.

- mhi,chan-names

  Usage: required

NETIF_F_TSO_ECN means that hardware can properly split packets with CWR bit

set, be it TCPv4 (when NETIF_F_TSO is enabled) or TCPv6 (NETIF_F_TSO6).

 * Transmit UDP segmentation offload

NETIF_F_GSO_UDP_GSO_L4 accepts a single UDP header with a payload that exceeds

gso_size. On segmentation, it segments the payload on gso_size boundaries and

replicates the network and UDP headers (fixing up the last one if less than

gso_size).

 * Transmit DMA from high memory

On platforms where this is relevant, NETIF_F_HIGHDMA signals that