2 * Copyright (C) 2011, 2012 The Android Open Source Project
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 #ifndef ANDROID_NFC_HAL_INTERFACE_H
18 #define ANDROID_NFC_HAL_INTERFACE_H
22 #include <sys/cdefs.h>
23 #include <sys/types.h>
25 #include <hardware/hardware.h>
30 /* NFC device HAL for NCI-based NFC controllers.
32 * This HAL allows NCI silicon vendors to make use
33 * of the core NCI stack in Android for their own silicon.
35 * The responibilities of the NCI HAL implementation
38 * - Implement the transport to the NFC controller
39 * - Implement each of the HAL methods specified below as applicable to their silicon
40 * - Pass up received NCI messages from the controller to the stack
42 * A simplified timeline of NCI HAL method calls:
43 * 1) Core NCI stack calls open()
44 * 2) Core NCI stack executes CORE_RESET and CORE_INIT through calls to write()
45 * 3) Core NCI stack calls core_initialized() to allow HAL to do post-init configuration
46 * 4) Core NCI stack calls pre_discover() to allow HAL to prepare for RF discovery
47 * 5) Core NCI stack starts discovery through calls to write()
48 * 6) Core NCI stack stops discovery through calls to write() (e.g. screen turns off)
49 * 7) Core NCI stack calls pre_discover() to prepare for RF discovery (e.g. screen turned back on)
50 * 8) Core NCI stack starts discovery through calls to write()
53 * 9) Core NCI stack calls close()
55 #define NFC_NCI_HARDWARE_MODULE_ID "nfc_nci"
56 #define NFC_NCI_CONTROLLER "nci"
59 * nfc_nci_module_t should contain module-specific parameters
61 typedef struct nfc_nci_module_t
{
62 struct hw_module_t common
;
66 * HAL events that can be passed back to the stack
68 typedef uint8_t nfc_event_t
;
71 HAL_NFC_OPEN_CPLT_EVT
= 0x00,
72 HAL_NFC_CLOSE_CPLT_EVT
= 0x01,
73 HAL_NFC_POST_INIT_CPLT_EVT
= 0x02,
74 HAL_NFC_PRE_DISCOVER_CPLT_EVT
= 0x03,
75 HAL_NFC_REQUEST_CONTROL_EVT
= 0x04,
76 HAL_NFC_RELEASE_CONTROL_EVT
= 0x05,
77 HAL_NFC_ERROR_EVT
= 0x06
81 * Allowed status return values for each of the HAL methods
83 typedef uint8_t nfc_status_t
;
86 HAL_NFC_STATUS_OK
= 0x00,
87 HAL_NFC_STATUS_FAILED
= 0x01,
88 HAL_NFC_STATUS_ERR_TRANSPORT
= 0x02,
89 HAL_NFC_STATUS_ERR_CMD_TIMEOUT
= 0x03,
90 HAL_NFC_STATUS_REFUSED
= 0x04
94 * The callback passed in from the NFC stack that the HAL
95 * can use to pass events back to the stack.
97 typedef void (nfc_stack_callback_t
) (nfc_event_t event
, nfc_status_t event_status
);
100 * The callback passed in from the NFC stack that the HAL
101 * can use to pass incomming data to the stack.
103 typedef void (nfc_stack_data_callback_t
) (uint16_t data_len
, uint8_t* p_data
);
105 /* nfc_nci_device_t starts with a hw_device_t struct,
106 * followed by device-specific methods and members.
108 * All methods in the NCI HAL are asynchronous.
110 typedef struct nfc_nci_device
{
111 struct hw_device_t common
;
113 * (*open)() Opens the NFC controller device and performs initialization.
114 * This may include patch download and other vendor-specific initialization.
116 * If open completes successfully, the controller should be ready to perform
117 * NCI initialization - ie accept CORE_RESET and subsequent commands through
120 * If open() returns 0, the NCI stack will wait for a HAL_NFC_OPEN_CPLT_EVT
123 * If open() returns any other value, the NCI stack will stop.
126 int (*open
)(const struct nfc_nci_device
*p_dev
, nfc_stack_callback_t
*p_cback
,
127 nfc_stack_data_callback_t
*p_data_cback
);
130 * (*write)() Performs an NCI write.
132 * This method may queue writes and return immediately. The only
133 * requirement is that the writes are executed in order.
135 int (*write
)(const struct nfc_nci_device
*p_dev
, uint16_t data_len
, const uint8_t *p_data
);
138 * (*core_initialized)() is called after the CORE_INIT_RSP is received from the NFCC.
139 * At this time, the HAL can do any chip-specific configuration.
141 * If core_initialized() returns 0, the NCI stack will wait for a HAL_NFC_POST_INIT_CPLT_EVT
144 * If core_initialized() returns any other value, the NCI stack will continue
147 int (*core_initialized
)(const struct nfc_nci_device
*p_dev
, uint8_t* p_core_init_rsp_params
);
150 * (*pre_discover)() Is called every time before starting RF discovery.
151 * It is a good place to do vendor-specific configuration that must be
152 * performed every time RF discovery is about to be started.
154 * If pre_discover() returns 0, the NCI stack will wait for a HAL_NFC_PRE_DISCOVER_CPLT_EVT
157 * If pre_discover() returns any other value, the NCI stack will start
158 * RF discovery immediately.
160 int (*pre_discover
)(const struct nfc_nci_device
*p_dev
);
163 * (*close)() Closed the NFC controller. Should free all resources.
165 int (*close
)(const struct nfc_nci_device
*p_dev
);
168 * (*control_granted)() Grant HAL the exclusive control to send NCI commands.
169 * Called in response to HAL_REQUEST_CONTROL_EVT.
170 * Must only be called when there are no NCI commands pending.
171 * HAL_RELEASE_CONTROL_EVT will notify when HAL no longer needs exclusive control.
173 int (*control_granted
)(const struct nfc_nci_device
*p_dev
);
176 * (*power_cycle)() Restart controller by power cyle;
177 * HAL_OPEN_CPLT_EVT will notify when operation is complete.
179 int (*power_cycle
)(const struct nfc_nci_device
*p_dev
);
183 * Convenience methods that the NFC stack can use to open
184 * and close an NCI device
186 static inline int nfc_nci_open(const struct hw_module_t
* module
,
187 nfc_nci_device_t
** dev
) {
188 return module
->methods
->open(module
, NFC_NCI_CONTROLLER
,
189 (struct hw_device_t
**) dev
);
192 static inline int nfc_nci_close(nfc_nci_device_t
* dev
) {
193 return dev
->common
.close(&dev
->common
);
200 * This is a limited NFC HAL for NXP PN544-based devices.
201 * This HAL as Android is moving to
202 * an NCI-based NFC stack.
204 * All NCI-based NFC controllers should use the NFC-NCI
206 * Begin PN544 specific HAL
208 #define NFC_HARDWARE_MODULE_ID "nfc"
210 #define NFC_PN544_CONTROLLER "pn544"
212 typedef struct nfc_module_t
{
213 struct hw_module_t common
;
220 * USB (uses UART DAL)
223 PN544_LINK_TYPE_UART
,
226 PN544_LINK_TYPE_INVALID
,
227 } nfc_pn544_linktype
;
230 struct hw_device_t common
;
232 /* The number of EEPROM registers to write */
233 uint32_t num_eeprom_settings
;
235 /* The actual EEPROM settings
236 * For PN544, each EEPROM setting is a 4-byte entry,
237 * of the format [0x00, addr_msb, addr_lsb, value].
239 uint8_t* eeprom_settings
;
241 /* The link type to which the PN544 is connected */
242 nfc_pn544_linktype linktype
;
244 /* The device node to which the PN544 is connected */
245 const char* device_node
;
247 /* On Crespo we had an I2C issue that would cause us to sometimes read
248 * the I2C slave address (0x57) over the bus. libnfc contains
249 * a hack to ignore this byte and try to read the length byte
251 * Set to 0 to disable the workaround, 1 to enable it.
253 uint8_t enable_i2c_workaround
;
254 /* I2C slave address. Multiple I2C addresses are
255 * possible for PN544 module. Configure address according to
258 uint8_t i2c_device_address
;
259 } nfc_pn544_device_t
;
261 static inline int nfc_pn544_open(const struct hw_module_t
* module
,
262 nfc_pn544_device_t
** dev
) {
263 return module
->methods
->open(module
, NFC_PN544_CONTROLLER
,
264 (struct hw_device_t
**) dev
);
267 static inline int nfc_pn544_close(nfc_pn544_device_t
* dev
) {
268 return dev
->common
.close(&dev
->common
);
271 * End PN544 specific HAL
276 #endif // ANDROID_NFC_HAL_INTERFACE_H