1 /* SPDX-License-Identifier: GPL-2.0+ */ 2 /* 3 * ipmi.h 4 * 5 * MontaVista IPMI interface 6 * 7 * Author: MontaVista Software, Inc. 8 * Corey Minyard <minyard@mvista.com> 9 * source@mvista.com 10 * 11 * Copyright 2002 MontaVista Software Inc. 12 * 13 */ 14 #ifndef __LINUX_IPMI_H 15 #define __LINUX_IPMI_H 16 17 #include <uapi/linux/ipmi.h> 18 19 #include <linux/list.h> 20 #include <linux/proc_fs.h> 21 #include <linux/acpi.h> /* For acpi_handle */ 22 23 struct module; 24 struct device; 25 26 /* 27 * Opaque type for a IPMI message user. One of these is needed to 28 * send and receive messages. 29 */ 30 struct ipmi_user; 31 32 /* 33 * Stuff coming from the receive interface comes as one of these. 34 * They are allocated, the receiver must free them with 35 * ipmi_free_recv_msg() when done with the message. The link is not 36 * used after the message is delivered, so the upper layer may use the 37 * link to build a linked list, if it likes. 38 */ 39 struct ipmi_recv_msg { 40 struct list_head link; 41 42 /* 43 * The type of message as defined in the "Receive Types" 44 * defines above. 45 */ 46 int recv_type; 47 48 struct ipmi_user *user; 49 struct ipmi_addr addr; 50 long msgid; 51 struct kernel_ipmi_msg msg; 52 53 /* 54 * The user_msg_data is the data supplied when a message was 55 * sent, if this is a response to a sent message. If this is 56 * not a response to a sent message, then user_msg_data will 57 * be NULL. If the user above is NULL, then this will be the 58 * intf. 59 */ 60 void *user_msg_data; 61 62 /* 63 * Call this when done with the message. It will presumably free 64 * the message and do any other necessary cleanup. 65 */ 66 void (*done)(struct ipmi_recv_msg *msg); 67 68 /* 69 * Place-holder for the data, don't make any assumptions about 70 * the size or existence of this, since it may change. 71 */ 72 unsigned char msg_data[IPMI_MAX_MSG_LENGTH]; 73 }; 74 75 /* Allocate and free the receive message. */ 76 void ipmi_free_recv_msg(struct ipmi_recv_msg *msg); 77 78 struct ipmi_user_hndl { 79 /* 80 * Routine type to call when a message needs to be routed to 81 * the upper layer. This will be called with some locks held, 82 * the only IPMI routines that can be called are ipmi_request 83 * and the alloc/free operations. The handler_data is the 84 * variable supplied when the receive handler was registered. 85 */ 86 void (*ipmi_recv_hndl)(struct ipmi_recv_msg *msg, 87 void *user_msg_data); 88 89 /* 90 * Called when the interface detects a watchdog pre-timeout. If 91 * this is NULL, it will be ignored for the user. 92 */ 93 void (*ipmi_watchdog_pretimeout)(void *handler_data); 94 95 /* 96 * If not NULL, called at panic time after the interface has 97 * been set up to handle run to completion. 98 */ 99 void (*ipmi_panic_handler)(void *handler_data); 100 101 /* 102 * Called when the interface has been removed. After this returns 103 * the user handle will be invalid. The interface may or may 104 * not be usable when this is called, but it will return errors 105 * if it is not usable. 106 */ 107 void (*shutdown)(void *handler_data); 108 }; 109 110 /* Create a new user of the IPMI layer on the given interface number. */ 111 int ipmi_create_user(unsigned int if_num, 112 const struct ipmi_user_hndl *handler, 113 void *handler_data, 114 struct ipmi_user **user); 115 116 /* 117 * Destroy the given user of the IPMI layer. Note that after this 118 * function returns, the system is guaranteed to not call any 119 * callbacks for the user. Thus as long as you destroy all the users 120 * before you unload a module, you will be safe. And if you destroy 121 * the users before you destroy the callback structures, it should be 122 * safe, too. 123 */ 124 int ipmi_destroy_user(struct ipmi_user *user); 125 126 /* Get the IPMI version of the BMC we are talking to. */ 127 int ipmi_get_version(struct ipmi_user *user, 128 unsigned char *major, 129 unsigned char *minor); 130 131 /* 132 * Set and get the slave address and LUN that we will use for our 133 * source messages. Note that this affects the interface, not just 134 * this user, so it will affect all users of this interface. This is 135 * so some initialization code can come in and do the OEM-specific 136 * things it takes to determine your address (if not the BMC) and set 137 * it for everyone else. Note that each channel can have its own 138 * address. 139 */ 140 int ipmi_set_my_address(struct ipmi_user *user, 141 unsigned int channel, 142 unsigned char address); 143 int ipmi_get_my_address(struct ipmi_user *user, 144 unsigned int channel, 145 unsigned char *address); 146 int ipmi_set_my_LUN(struct ipmi_user *user, 147 unsigned int channel, 148 unsigned char LUN); 149 int ipmi_get_my_LUN(struct ipmi_user *user, 150 unsigned int channel, 151 unsigned char *LUN); 152 153 /* 154 * Like ipmi_request, but lets you specify the number of retries and 155 * the retry time. The retries is the number of times the message 156 * will be resent if no reply is received. If set to -1, the default 157 * value will be used. The retry time is the time in milliseconds 158 * between retries. If set to zero, the default value will be 159 * used. 160 * 161 * Don't use this unless you *really* have to. It's primarily for the 162 * IPMI over LAN converter; since the LAN stuff does its own retries, 163 * it makes no sense to do it here. However, this can be used if you 164 * have unusual requirements. 165 */ 166 int ipmi_request_settime(struct ipmi_user *user, 167 struct ipmi_addr *addr, 168 long msgid, 169 struct kernel_ipmi_msg *msg, 170 void *user_msg_data, 171 int priority, 172 int max_retries, 173 unsigned int retry_time_ms); 174 175 /* 176 * Like ipmi_request, but with messages supplied. This will not 177 * allocate any memory, and the messages may be statically allocated 178 * (just make sure to do the "done" handling on them). Note that this 179 * is primarily for the watchdog timer, since it should be able to 180 * send messages even if no memory is available. This is subject to 181 * change as the system changes, so don't use it unless you REALLY 182 * have to. 183 */ 184 int ipmi_request_supply_msgs(struct ipmi_user *user, 185 struct ipmi_addr *addr, 186 long msgid, 187 struct kernel_ipmi_msg *msg, 188 void *user_msg_data, 189 void *supplied_smi, 190 struct ipmi_recv_msg *supplied_recv, 191 int priority); 192 193 /* 194 * Poll the IPMI interface for the user. This causes the IPMI code to 195 * do an immediate check for information from the driver and handle 196 * anything that is immediately pending. This will not block in any 197 * way. This is useful if you need to spin waiting for something to 198 * happen in the IPMI driver. 199 */ 200 void ipmi_poll_interface(struct ipmi_user *user); 201 202 /* 203 * When commands come in to the SMS, the user can register to receive 204 * them. Only one user can be listening on a specific netfn/cmd/chan tuple 205 * at a time, you will get an EBUSY error if the command is already 206 * registered. If a command is received that does not have a user 207 * registered, the driver will automatically return the proper 208 * error. Channels are specified as a bitfield, use IPMI_CHAN_ALL to 209 * mean all channels. 210 */ 211 int ipmi_register_for_cmd(struct ipmi_user *user, 212 unsigned char netfn, 213 unsigned char cmd, 214 unsigned int chans); 215 int ipmi_unregister_for_cmd(struct ipmi_user *user, 216 unsigned char netfn, 217 unsigned char cmd, 218 unsigned int chans); 219 220 /* 221 * Go into a mode where the driver will not autonomously attempt to do 222 * things with the interface. It will still respond to attentions and 223 * interrupts, and it will expect that commands will complete. It 224 * will not automatcially check for flags, events, or things of that 225 * nature. 226 * 227 * This is primarily used for firmware upgrades. The idea is that 228 * when you go into firmware upgrade mode, you do this operation 229 * and the driver will not attempt to do anything but what you tell 230 * it or what the BMC asks for. 231 * 232 * Note that if you send a command that resets the BMC, the driver 233 * will still expect a response from that command. So the BMC should 234 * reset itself *after* the response is sent. Resetting before the 235 * response is just silly. 236 * 237 * If in auto maintenance mode, the driver will automatically go into 238 * maintenance mode for 30 seconds if it sees a cold reset, a warm 239 * reset, or a firmware NetFN. This means that code that uses only 240 * firmware NetFN commands to do upgrades will work automatically 241 * without change, assuming it sends a message every 30 seconds or 242 * less. 243 * 244 * See the IPMI_MAINTENANCE_MODE_xxx defines for what the mode means. 245 */ 246 int ipmi_get_maintenance_mode(struct ipmi_user *user); 247 int ipmi_set_maintenance_mode(struct ipmi_user *user, int mode); 248 249 /* 250 * When the user is created, it will not receive IPMI events by 251 * default. The user must set this to TRUE to get incoming events. 252 * The first user that sets this to TRUE will receive all events that 253 * have been queued while no one was waiting for events. 254 */ 255 int ipmi_set_gets_events(struct ipmi_user *user, bool val); 256 257 /* 258 * Called when a new SMI is registered. This will also be called on 259 * every existing interface when a new watcher is registered with 260 * ipmi_smi_watcher_register(). 261 */ 262 struct ipmi_smi_watcher { 263 struct list_head link; 264 265 /* 266 * You must set the owner to the current module, if you are in 267 * a module (generally just set it to "THIS_MODULE"). 268 */ 269 struct module *owner; 270 271 /* 272 * These two are called with read locks held for the interface 273 * the watcher list. So you can add and remove users from the 274 * IPMI interface, send messages, etc., but you cannot add 275 * or remove SMI watchers or SMI interfaces. 276 */ 277 void (*new_smi)(int if_num, struct device *dev); 278 void (*smi_gone)(int if_num); 279 }; 280 281 int ipmi_smi_watcher_register(struct ipmi_smi_watcher *watcher); 282 int ipmi_smi_watcher_unregister(struct ipmi_smi_watcher *watcher); 283 284 /* 285 * The following are various helper functions for dealing with IPMI 286 * addresses. 287 */ 288 289 /* Return the maximum length of an IPMI address given it's type. */ 290 unsigned int ipmi_addr_length(int addr_type); 291 292 /* Validate that the given IPMI address is valid. */ 293 int ipmi_validate_addr(struct ipmi_addr *addr, int len); 294 295 /* 296 * How did the IPMI driver find out about the device? 297 */ 298 enum ipmi_addr_src { 299 SI_INVALID = 0, SI_HOTMOD, SI_HARDCODED, SI_SPMI, SI_ACPI, SI_SMBIOS, 300 SI_PCI, SI_DEVICETREE, SI_PLATFORM, SI_LAST 301 }; 302 const char *ipmi_addr_src_to_str(enum ipmi_addr_src src); 303 304 union ipmi_smi_info_union { 305 #ifdef CONFIG_ACPI 306 /* 307 * the acpi_info element is defined for the SI_ACPI 308 * address type 309 */ 310 struct { 311 acpi_handle acpi_handle; 312 } acpi_info; 313 #endif 314 }; 315 316 struct ipmi_smi_info { 317 enum ipmi_addr_src addr_src; 318 319 /* 320 * Base device for the interface. Don't forget to put this when 321 * you are done. 322 */ 323 struct device *dev; 324 325 /* 326 * The addr_info provides more detailed info for some IPMI 327 * devices, depending on the addr_src. Currently only SI_ACPI 328 * info is provided. 329 */ 330 union ipmi_smi_info_union addr_info; 331 }; 332 333 /* This is to get the private info of struct ipmi_smi */ 334 extern int ipmi_get_smi_info(int if_num, struct ipmi_smi_info *data); 335 336 #endif /* __LINUX_IPMI_H */ 337