blob: b7d70896cea21b7a9fac81c52aef1a2d715ba657 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
/* Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
/* Host command module for Chrome EC */
#ifndef __CROS_EC_HOST_COMMAND_H
#define __CROS_EC_HOST_COMMAND_H
#include "common.h"
#include "ec_commands.h"
/* Args for host command handler */
struct host_cmd_handler_args {
/*
* The driver that receives the command sets up the send_response()
* handler. Once the command is processed this handler is called to
* send the response back to the host.
*/
void (*send_response)(struct host_cmd_handler_args *args);
uint8_t command; /* Command (e.g., EC_CMD_FLASH_GET_INFO) */
uint8_t version; /* Version of command (0-31) */
uint8_t flags; /* Flags (EC_HOST_ARGS_FLAG_*) */
uint8_t params_size; /* Size of input parameters in bytes */
uint8_t i2c_old_response; /* (for I2C) send an old-style response */
const void *params; /* Input parameters */
/*
* Pointer to output response data buffer. On input to the handler,
* points to a buffer of size response_max. Command handler can change
* this to point to a different location instead of memcpy()'ing data
* into the provided buffer.
*/
void *response;
/*
* Maximum size of response buffer provided to command handler. If the
* handler changes response to point to its own larger buffer, it may
* return a response_size greater than response_max.
*/
uint8_t response_max;
uint8_t response_size; /* Size of data pointed to by resp_ptr */
/*
* This is the result returned by command and therefore the status to
* be reported from the command execution to the host. The driver
* should set this to EC_RES_SUCCESS on receipt of a valid command.
* It is then passed back to the driver via send_response() when
* command execution is complete. The driver may still override this
* when sending the response back to the host if it detects an error
* in the response or in its own operation.
*/
enum ec_status result;
};
/* Host command */
struct host_command {
/*
* Handler for the command. Args points to context for handler.
* Returns result status (EC_RES_*).
*/
int (*handler)(struct host_cmd_handler_args *args);
/* Command code */
int command;
/* Mask of supported versions */
int version_mask;
};
/**
* Return a pointer to the memory-mapped buffer.
*
* This buffer is EC_MEMMAP_SIZE bytes long, is writable at any time, and the
* host can read it at any time.
*
* @param offset Offset within the range to return
* @return pointer to the buffer at that offset
*/
uint8_t *host_get_memmap(int offset);
/**
* Process a host command and return its response
*
* @param args Command handler args
* @return resulting status
*/
enum ec_status host_command_process(struct host_cmd_handler_args *args);
/**
* Set one or more host event bits.
*
* @param mask Event bits to set (use EC_HOST_EVENT_MASK()).
*/
void host_set_events(uint32_t mask);
/**
* Set a single host event.
*
* @param event Event to set (EC_HOST_EVENT_*).
*/
static inline void host_set_single_event(int event)
{
host_set_events(EC_HOST_EVENT_MASK(event));
}
/**
* Clear one or more host event bits.
*
* @param mask Event bits to clear (use EC_HOST_EVENT_MASK()).
* Write 1 to a bit to clear it.
*/
void host_clear_events(uint32_t mask);
/**
* Return the raw event state.
*/
uint32_t host_get_events(void);
/**
* Send a response to the relevent driver for transmission
*
* Once command processing is complete, this is used to send a response
* back to the host.
*
* @param args Contains response to send
*/
void host_send_response(struct host_cmd_handler_args *args);
/**
* Called by host interface module when a command is received.
*/
void host_command_received(struct host_cmd_handler_args *args);
/* Register a host command handler */
#define DECLARE_HOST_COMMAND(command, routine, version_mask) \
const struct host_command __host_cmd_##command \
__attribute__((section(".rodata.hcmds"))) \
= {routine, command, version_mask}
#endif /* __CROS_EC_HOST_COMMAND_H */
|
