1 /* SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 */ 2 /* 3 * Copyright (C) 2017-2020 Mellanox Technologies Ltd. 4 */ 5 6 #ifndef __LINUX_PLATFORM_DATA_MLXREG_H 7 #define __LINUX_PLATFORM_DATA_MLXREG_H 8 9 #define MLXREG_CORE_LABEL_MAX_SIZE 32 10 #define MLXREG_CORE_WD_FEATURE_NOWAYOUT BIT(0) 11 #define MLXREG_CORE_WD_FEATURE_START_AT_BOOT BIT(1) 12 13 /** 14 * enum mlxreg_wdt_type - type of HW watchdog 15 * 16 * TYPE1 HW watchdog implementation exist in old systems. 17 * All new systems have TYPE2 HW watchdog. 18 * TYPE3 HW watchdog can exist on all systems with new CPLD. 19 * TYPE3 is selected by WD capability bit. 20 */ 21 enum mlxreg_wdt_type { 22 MLX_WDT_TYPE1, 23 MLX_WDT_TYPE2, 24 MLX_WDT_TYPE3, 25 }; 26 27 /** 28 * enum mlxreg_hotplug_kind - kind of hotplug entry 29 * 30 * @MLXREG_HOTPLUG_DEVICE_NA: do not care; 31 * @MLXREG_HOTPLUG_LC_PRESENT: entry for line card presence in/out events; 32 * @MLXREG_HOTPLUG_LC_VERIFIED: entry for line card verification status events 33 * coming after line card security signature validation; 34 * @MLXREG_HOTPLUG_LC_POWERED: entry for line card power on/off events; 35 * @MLXREG_HOTPLUG_LC_SYNCED: entry for line card synchronization events, coming 36 * after hardware-firmware synchronization handshake; 37 * @MLXREG_HOTPLUG_LC_READY: entry for line card ready events, indicating line card 38 PHYs ready / unready state; 39 * @MLXREG_HOTPLUG_LC_ACTIVE: entry for line card active events, indicating firmware 40 * availability / unavailability for the ports on line card; 41 * @MLXREG_HOTPLUG_LC_THERMAL: entry for line card thermal shutdown events, positive 42 * event indicates that system should power off the line 43 * card for which this event has been received; 44 */ 45 enum mlxreg_hotplug_kind { 46 MLXREG_HOTPLUG_DEVICE_NA = 0, 47 MLXREG_HOTPLUG_LC_PRESENT = 1, 48 MLXREG_HOTPLUG_LC_VERIFIED = 2, 49 MLXREG_HOTPLUG_LC_POWERED = 3, 50 MLXREG_HOTPLUG_LC_SYNCED = 4, 51 MLXREG_HOTPLUG_LC_READY = 5, 52 MLXREG_HOTPLUG_LC_ACTIVE = 6, 53 MLXREG_HOTPLUG_LC_THERMAL = 7, 54 }; 55 56 /** 57 * enum mlxreg_hotplug_device_action - hotplug device action required for 58 * driver's connectivity 59 * 60 * @MLXREG_HOTPLUG_DEVICE_DEFAULT_ACTION: probe device for 'on' event, remove 61 * for 'off' event; 62 * @MLXREG_HOTPLUG_DEVICE_PLATFORM_ACTION: probe platform device for 'on' 63 * event, remove for 'off' event; 64 * @MLXREG_HOTPLUG_DEVICE_NO_ACTION: no connectivity action is required; 65 */ 66 enum mlxreg_hotplug_device_action { 67 MLXREG_HOTPLUG_DEVICE_DEFAULT_ACTION = 0, 68 MLXREG_HOTPLUG_DEVICE_PLATFORM_ACTION = 1, 69 MLXREG_HOTPLUG_DEVICE_NO_ACTION = 2, 70 }; 71 72 /** 73 * struct mlxreg_core_hotplug_notifier - hotplug notifier block: 74 * 75 * @identity: notifier identity name; 76 * @handle: user handle to be passed by user handler function; 77 * @user_handler: user handler function associated with the event; 78 */ 79 struct mlxreg_core_hotplug_notifier { 80 char identity[MLXREG_CORE_LABEL_MAX_SIZE]; 81 void *handle; 82 int (*user_handler)(void *handle, enum mlxreg_hotplug_kind kind, u8 action); 83 }; 84 85 /** 86 * struct mlxreg_hotplug_device - I2C device data: 87 * 88 * @adapter: I2C device adapter; 89 * @client: I2C device client; 90 * @brdinfo: device board information; 91 * @nr: I2C device adapter number, to which device is to be attached; 92 * @pdev: platform device, if device is instantiated as a platform device; 93 * @action: action to be performed upon event receiving; 94 * @handle: user handle to be passed by user handler function; 95 * @user_handler: user handler function associated with the event; 96 * @notifier: pointer to event notifier block; 97 * 98 * Structure represents I2C hotplug device static data (board topology) and 99 * dynamic data (related kernel objects handles). 100 */ 101 struct mlxreg_hotplug_device { 102 struct i2c_adapter *adapter; 103 struct i2c_client *client; 104 struct i2c_board_info *brdinfo; 105 int nr; 106 struct platform_device *pdev; 107 enum mlxreg_hotplug_device_action action; 108 void *handle; 109 int (*user_handler)(void *handle, enum mlxreg_hotplug_kind kind, u8 action); 110 struct mlxreg_core_hotplug_notifier *notifier; 111 }; 112 113 /** 114 * struct mlxreg_core_data - attributes control data: 115 * 116 * @label: attribute label; 117 * @reg: attribute register; 118 * @mask: attribute access mask; 119 * @bit: attribute effective bit; 120 * @capability: attribute capability register; 121 * @reg_prsnt: attribute presence register; 122 * @reg_sync: attribute synch register; 123 * @reg_pwr: attribute power register; 124 * @reg_ena: attribute enable register; 125 * @mode: access mode; 126 * @np - pointer to node platform associated with attribute; 127 * @hpdev - hotplug device data; 128 * @notifier: pointer to event notifier block; 129 * @health_cntr: dynamic device health indication counter; 130 * @attached: true if device has been attached after good health indication; 131 * @regnum: number of registers occupied by multi-register attribute; 132 * @slot: slot number, at which device is located; 133 * @secured: if set indicates that entry access is secured; 134 */ 135 struct mlxreg_core_data { 136 char label[MLXREG_CORE_LABEL_MAX_SIZE]; 137 u32 reg; 138 u32 mask; 139 u32 bit; 140 u32 capability; 141 u32 reg_prsnt; 142 u32 reg_sync; 143 u32 reg_pwr; 144 u32 reg_ena; 145 umode_t mode; 146 struct device_node *np; 147 struct mlxreg_hotplug_device hpdev; 148 struct mlxreg_core_hotplug_notifier *notifier; 149 u32 health_cntr; 150 bool attached; 151 u8 regnum; 152 u8 slot; 153 u8 secured; 154 }; 155 156 /** 157 * struct mlxreg_core_item - same type components controlled by the driver: 158 * 159 * @data: component data; 160 * @kind: kind of hotplug attribute; 161 * @aggr_mask: group aggregation mask; 162 * @reg: group interrupt status register; 163 * @mask: group interrupt mask; 164 * @capability: group capability register; 165 * @cache: last status value for elements fro the same group; 166 * @count: number of available elements in the group; 167 * @ind: element's index inside the group; 168 * @inversed: if 0: 0 for signal status is OK, if 1 - 1 is OK; 169 * @health: true if device has health indication, false in other case; 170 */ 171 struct mlxreg_core_item { 172 struct mlxreg_core_data *data; 173 enum mlxreg_hotplug_kind kind; 174 u32 aggr_mask; 175 u32 reg; 176 u32 mask; 177 u32 capability; 178 u32 cache; 179 u8 count; 180 u8 ind; 181 u8 inversed; 182 u8 health; 183 }; 184 185 /** 186 * struct mlxreg_core_platform_data - platform data: 187 * 188 * @data: instance private data; 189 * @regmap: register map of parent device; 190 * @counter: number of instances; 191 * @features: supported features of device; 192 * @version: implementation version; 193 * @identity: device identity name; 194 * @capability: device capability register; 195 */ 196 struct mlxreg_core_platform_data { 197 struct mlxreg_core_data *data; 198 void *regmap; 199 int counter; 200 u32 features; 201 u32 version; 202 char identity[MLXREG_CORE_LABEL_MAX_SIZE]; 203 u32 capability; 204 }; 205 206 /** 207 * struct mlxreg_core_hotplug_platform_data - hotplug platform data: 208 * 209 * @items: same type components with the hotplug capability; 210 * @irq: platform interrupt number; 211 * @regmap: register map of parent device; 212 * @counter: number of the components with the hotplug capability; 213 * @cell: location of top aggregation interrupt register; 214 * @mask: top aggregation interrupt common mask; 215 * @cell_low: location of low aggregation interrupt register; 216 * @mask_low: low aggregation interrupt common mask; 217 * @deferred_nr: I2C adapter number must be exist prior probing execution; 218 * @shift_nr: I2C adapter numbers must be incremented by this value; 219 * @addr: mapped resource address; 220 * @handle: handle to be passed by callback; 221 * @completion_notify: callback to notify when platform driver probing is done; 222 */ 223 struct mlxreg_core_hotplug_platform_data { 224 struct mlxreg_core_item *items; 225 int irq; 226 void *regmap; 227 int counter; 228 u32 cell; 229 u32 mask; 230 u32 cell_low; 231 u32 mask_low; 232 int deferred_nr; 233 int shift_nr; 234 void __iomem *addr; 235 void *handle; 236 int (*completion_notify)(void *handle, int id); 237 }; 238 239 #endif /* __LINUX_PLATFORM_DATA_MLXREG_H */ 240