Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * ipmi.h | |
3 | * | |
4 | * MontaVista IPMI interface | |
5 | * | |
6 | * Author: MontaVista Software, Inc. | |
7 | * Corey Minyard <minyard@mvista.com> | |
8 | * source@mvista.com | |
9 | * | |
10 | * Copyright 2002 MontaVista Software Inc. | |
11 | * | |
12 | * This program is free software; you can redistribute it and/or modify it | |
13 | * under the terms of the GNU General Public License as published by the | |
14 | * Free Software Foundation; either version 2 of the License, or (at your | |
15 | * option) any later version. | |
16 | * | |
17 | * | |
18 | * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED | |
19 | * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF | |
20 | * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. | |
21 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, | |
22 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, | |
23 | * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS | |
24 | * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | |
25 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR | |
26 | * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE | |
27 | * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
28 | * | |
29 | * You should have received a copy of the GNU General Public License along | |
30 | * with this program; if not, write to the Free Software Foundation, Inc., | |
31 | * 675 Mass Ave, Cambridge, MA 02139, USA. | |
32 | */ | |
33 | ||
34 | #ifndef __LINUX_IPMI_H | |
35 | #define __LINUX_IPMI_H | |
36 | ||
37 | #include <linux/ipmi_msgdefs.h> | |
07766f24 | 38 | #include <linux/compiler.h> |
1da177e4 LT |
39 | |
40 | /* | |
41 | * This file describes an interface to an IPMI driver. You have to | |
42 | * have a fairly good understanding of IPMI to use this, so go read | |
43 | * the specs first before actually trying to do anything. | |
44 | * | |
45 | * With that said, this driver provides a multi-user interface to the | |
46 | * IPMI driver, and it allows multiple IPMI physical interfaces below | |
47 | * the driver. The physical interfaces bind as a lower layer on the | |
48 | * driver. They appear as interfaces to the application using this | |
49 | * interface. | |
50 | * | |
51 | * Multi-user means that multiple applications may use the driver, | |
52 | * send commands, receive responses, etc. The driver keeps track of | |
53 | * commands the user sends and tracks the responses. The responses | |
54 | * will go back to the application that send the command. If the | |
55 | * response doesn't come back in time, the driver will return a | |
56 | * timeout error response to the application. Asynchronous events | |
57 | * from the BMC event queue will go to all users bound to the driver. | |
58 | * The incoming event queue in the BMC will automatically be flushed | |
59 | * if it becomes full and it is queried once a second to see if | |
60 | * anything is in it. Incoming commands to the driver will get | |
61 | * delivered as commands. | |
62 | * | |
63 | * This driver provides two main interfaces: one for in-kernel | |
64 | * applications and another for userland applications. The | |
65 | * capabilities are basically the same for both interface, although | |
66 | * the interfaces are somewhat different. The stuff in the | |
66ec2d77 | 67 | * #ifdef __KERNEL__ below is the in-kernel interface. The userland |
1da177e4 LT |
68 | * interface is defined later in the file. */ |
69 | ||
70 | ||
71 | ||
72 | /* | |
73 | * This is an overlay for all the address types, so it's easy to | |
74 | * determine the actual address type. This is kind of like addresses | |
75 | * work for sockets. | |
76 | */ | |
77 | #define IPMI_MAX_ADDR_SIZE 32 | |
c70d7499 | 78 | struct ipmi_addr { |
1da177e4 LT |
79 | /* Try to take these from the "Channel Medium Type" table |
80 | in section 6.5 of the IPMI 1.5 manual. */ | |
81 | int addr_type; | |
82 | short channel; | |
83 | char data[IPMI_MAX_ADDR_SIZE]; | |
84 | }; | |
85 | ||
86 | /* | |
87 | * When the address is not used, the type will be set to this value. | |
88 | * The channel is the BMC's channel number for the channel (usually | |
89 | * 0), or IPMC_BMC_CHANNEL if communicating directly with the BMC. | |
90 | */ | |
91 | #define IPMI_SYSTEM_INTERFACE_ADDR_TYPE 0x0c | |
c70d7499 | 92 | struct ipmi_system_interface_addr { |
1da177e4 LT |
93 | int addr_type; |
94 | short channel; | |
95 | unsigned char lun; | |
96 | }; | |
97 | ||
98 | /* An IPMB Address. */ | |
99 | #define IPMI_IPMB_ADDR_TYPE 0x01 | |
100 | /* Used for broadcast get device id as described in section 17.9 of the | |
c70d7499 | 101 | IPMI 1.5 manual. */ |
1da177e4 | 102 | #define IPMI_IPMB_BROADCAST_ADDR_TYPE 0x41 |
c70d7499 | 103 | struct ipmi_ipmb_addr { |
1da177e4 LT |
104 | int addr_type; |
105 | short channel; | |
106 | unsigned char slave_addr; | |
107 | unsigned char lun; | |
108 | }; | |
109 | ||
110 | /* | |
111 | * A LAN Address. This is an address to/from a LAN interface bridged | |
112 | * by the BMC, not an address actually out on the LAN. | |
113 | * | |
25985edc | 114 | * A conscious decision was made here to deviate slightly from the IPMI |
1da177e4 LT |
115 | * spec. We do not use rqSWID and rsSWID like it shows in the |
116 | * message. Instead, we use remote_SWID and local_SWID. This means | |
117 | * that any message (a request or response) from another device will | |
118 | * always have exactly the same address. If you didn't do this, | |
119 | * requests and responses from the same device would have different | |
120 | * addresses, and that's not too cool. | |
121 | * | |
122 | * In this address, the remote_SWID is always the SWID the remote | |
123 | * message came from, or the SWID we are sending the message to. | |
124 | * local_SWID is always our SWID. Note that having our SWID in the | |
125 | * message is a little weird, but this is required. | |
126 | */ | |
127 | #define IPMI_LAN_ADDR_TYPE 0x04 | |
c70d7499 | 128 | struct ipmi_lan_addr { |
1da177e4 LT |
129 | int addr_type; |
130 | short channel; | |
131 | unsigned char privilege; | |
132 | unsigned char session_handle; | |
133 | unsigned char remote_SWID; | |
134 | unsigned char local_SWID; | |
135 | unsigned char lun; | |
136 | }; | |
137 | ||
138 | ||
139 | /* | |
140 | * Channel for talking directly with the BMC. When using this | |
141 | * channel, This is for the system interface address type only. FIXME | |
142 | * - is this right, or should we use -1? | |
143 | */ | |
144 | #define IPMI_BMC_CHANNEL 0xf | |
145 | #define IPMI_NUM_CHANNELS 0x10 | |
146 | ||
c69c3127 CM |
147 | /* |
148 | * Used to signify an "all channel" bitmask. This is more than the | |
149 | * actual number of channels because this is used in userland and | |
150 | * will cover us if the number of channels is extended. | |
151 | */ | |
152 | #define IPMI_CHAN_ALL (~0) | |
153 | ||
1da177e4 LT |
154 | |
155 | /* | |
156 | * A raw IPMI message without any addressing. This covers both | |
157 | * commands and responses. The completion code is always the first | |
158 | * byte of data in the response (as the spec shows the messages laid | |
159 | * out). | |
160 | */ | |
c70d7499 | 161 | struct ipmi_msg { |
1da177e4 LT |
162 | unsigned char netfn; |
163 | unsigned char cmd; | |
164 | unsigned short data_len; | |
165 | unsigned char __user *data; | |
166 | }; | |
167 | ||
c70d7499 | 168 | struct kernel_ipmi_msg { |
1da177e4 LT |
169 | unsigned char netfn; |
170 | unsigned char cmd; | |
171 | unsigned short data_len; | |
172 | unsigned char *data; | |
173 | }; | |
174 | ||
175 | /* | |
176 | * Various defines that are useful for IPMI applications. | |
177 | */ | |
178 | #define IPMI_INVALID_CMD_COMPLETION_CODE 0xC1 | |
179 | #define IPMI_TIMEOUT_COMPLETION_CODE 0xC3 | |
180 | #define IPMI_UNKNOWN_ERR_COMPLETION_CODE 0xff | |
181 | ||
182 | ||
183 | /* | |
184 | * Receive types for messages coming from the receive interface. This | |
185 | * is used for the receive in-kernel interface and in the receive | |
186 | * IOCTL. | |
187 | * | |
188 | * The "IPMI_RESPONSE_RESPNOSE_TYPE" is a little strange sounding, but | |
189 | * it allows you to get the message results when you send a response | |
190 | * message. | |
191 | */ | |
192 | #define IPMI_RESPONSE_RECV_TYPE 1 /* A response to a command */ | |
193 | #define IPMI_ASYNC_EVENT_RECV_TYPE 2 /* Something from the event queue */ | |
194 | #define IPMI_CMD_RECV_TYPE 3 /* A command from somewhere else */ | |
195 | #define IPMI_RESPONSE_RESPONSE_TYPE 4 /* The response for | |
196 | a sent response, giving any | |
197 | error status for sending the | |
198 | response. When you send a | |
199 | response message, this will | |
200 | be returned. */ | |
4dec302f | 201 | #define IPMI_OEM_RECV_TYPE 5 /* The response for OEM Channels */ |
202 | ||
1da177e4 LT |
203 | /* Note that async events and received commands do not have a completion |
204 | code as the first byte of the incoming data, unlike a response. */ | |
205 | ||
206 | ||
b9675136 CM |
207 | /* |
208 | * Modes for ipmi_set_maint_mode() and the userland IOCTL. The AUTO | |
209 | * setting is the default and means it will be set on certain | |
210 | * commands. Hard setting it on and off will override automatic | |
211 | * operation. | |
212 | */ | |
213 | #define IPMI_MAINTENANCE_MODE_AUTO 0 | |
214 | #define IPMI_MAINTENANCE_MODE_OFF 1 | |
215 | #define IPMI_MAINTENANCE_MODE_ON 2 | |
1da177e4 LT |
216 | |
217 | #ifdef __KERNEL__ | |
218 | ||
219 | /* | |
220 | * The in-kernel interface. | |
221 | */ | |
222 | #include <linux/list.h> | |
3b625943 | 223 | #include <linux/proc_fs.h> |
3b625943 | 224 | |
de477254 | 225 | struct module; |
313162d0 | 226 | struct device; |
de477254 | 227 | |
1da177e4 LT |
228 | /* Opaque type for a IPMI message user. One of these is needed to |
229 | send and receive messages. */ | |
230 | typedef struct ipmi_user *ipmi_user_t; | |
231 | ||
232 | /* | |
233 | * Stuff coming from the receive interface comes as one of these. | |
234 | * They are allocated, the receiver must free them with | |
235 | * ipmi_free_recv_msg() when done with the message. The link is not | |
236 | * used after the message is delivered, so the upper layer may use the | |
237 | * link to build a linked list, if it likes. | |
238 | */ | |
c70d7499 | 239 | struct ipmi_recv_msg { |
1da177e4 LT |
240 | struct list_head link; |
241 | ||
242 | /* The type of message as defined in the "Receive Types" | |
c70d7499 | 243 | defines above. */ |
1da177e4 LT |
244 | int recv_type; |
245 | ||
246 | ipmi_user_t user; | |
247 | struct ipmi_addr addr; | |
248 | long msgid; | |
249 | struct kernel_ipmi_msg msg; | |
250 | ||
251 | /* The user_msg_data is the data supplied when a message was | |
252 | sent, if this is a response to a sent message. If this is | |
253 | not a response to a sent message, then user_msg_data will | |
56a55ec6 CM |
254 | be NULL. If the user above is NULL, then this will be the |
255 | intf. */ | |
1da177e4 LT |
256 | void *user_msg_data; |
257 | ||
258 | /* Call this when done with the message. It will presumably free | |
259 | the message and do any other necessary cleanup. */ | |
260 | void (*done)(struct ipmi_recv_msg *msg); | |
261 | ||
262 | /* Place-holder for the data, don't make any assumptions about | |
25985edc | 263 | the size or existence of this, since it may change. */ |
1da177e4 LT |
264 | unsigned char msg_data[IPMI_MAX_MSG_LENGTH]; |
265 | }; | |
266 | ||
267 | /* Allocate and free the receive message. */ | |
393d2cc3 | 268 | void ipmi_free_recv_msg(struct ipmi_recv_msg *msg); |
1da177e4 | 269 | |
c70d7499 CM |
270 | struct ipmi_user_hndl { |
271 | /* Routine type to call when a message needs to be routed to | |
1da177e4 LT |
272 | the upper layer. This will be called with some locks held, |
273 | the only IPMI routines that can be called are ipmi_request | |
274 | and the alloc/free operations. The handler_data is the | |
275 | variable supplied when the receive handler was registered. */ | |
276 | void (*ipmi_recv_hndl)(struct ipmi_recv_msg *msg, | |
277 | void *user_msg_data); | |
278 | ||
279 | /* Called when the interface detects a watchdog pre-timeout. If | |
280 | this is NULL, it will be ignored for the user. */ | |
281 | void (*ipmi_watchdog_pretimeout)(void *handler_data); | |
282 | }; | |
283 | ||
284 | /* Create a new user of the IPMI layer on the given interface number. */ | |
285 | int ipmi_create_user(unsigned int if_num, | |
286 | struct ipmi_user_hndl *handler, | |
287 | void *handler_data, | |
288 | ipmi_user_t *user); | |
289 | ||
290 | /* Destroy the given user of the IPMI layer. Note that after this | |
291 | function returns, the system is guaranteed to not call any | |
292 | callbacks for the user. Thus as long as you destroy all the users | |
293 | before you unload a module, you will be safe. And if you destroy | |
294 | the users before you destroy the callback structures, it should be | |
295 | safe, too. */ | |
296 | int ipmi_destroy_user(ipmi_user_t user); | |
297 | ||
298 | /* Get the IPMI version of the BMC we are talking to. */ | |
299 | void ipmi_get_version(ipmi_user_t user, | |
300 | unsigned char *major, | |
301 | unsigned char *minor); | |
302 | ||
303 | /* Set and get the slave address and LUN that we will use for our | |
304 | source messages. Note that this affects the interface, not just | |
305 | this user, so it will affect all users of this interface. This is | |
306 | so some initialization code can come in and do the OEM-specific | |
307 | things it takes to determine your address (if not the BMC) and set | |
c14979b9 CM |
308 | it for everyone else. Note that each channel can have its own address. */ |
309 | int ipmi_set_my_address(ipmi_user_t user, | |
310 | unsigned int channel, | |
311 | unsigned char address); | |
312 | int ipmi_get_my_address(ipmi_user_t user, | |
313 | unsigned int channel, | |
314 | unsigned char *address); | |
315 | int ipmi_set_my_LUN(ipmi_user_t user, | |
316 | unsigned int channel, | |
317 | unsigned char LUN); | |
318 | int ipmi_get_my_LUN(ipmi_user_t user, | |
319 | unsigned int channel, | |
320 | unsigned char *LUN); | |
1da177e4 LT |
321 | |
322 | /* | |
323 | * Like ipmi_request, but lets you specify the number of retries and | |
324 | * the retry time. The retries is the number of times the message | |
325 | * will be resent if no reply is received. If set to -1, the default | |
326 | * value will be used. The retry time is the time in milliseconds | |
327 | * between retries. If set to zero, the default value will be | |
328 | * used. | |
329 | * | |
330 | * Don't use this unless you *really* have to. It's primarily for the | |
331 | * IPMI over LAN converter; since the LAN stuff does its own retries, | |
332 | * it makes no sense to do it here. However, this can be used if you | |
333 | * have unusual requirements. | |
334 | */ | |
335 | int ipmi_request_settime(ipmi_user_t user, | |
336 | struct ipmi_addr *addr, | |
337 | long msgid, | |
338 | struct kernel_ipmi_msg *msg, | |
339 | void *user_msg_data, | |
340 | int priority, | |
341 | int max_retries, | |
342 | unsigned int retry_time_ms); | |
343 | ||
344 | /* | |
345 | * Like ipmi_request, but with messages supplied. This will not | |
346 | * allocate any memory, and the messages may be statically allocated | |
347 | * (just make sure to do the "done" handling on them). Note that this | |
348 | * is primarily for the watchdog timer, since it should be able to | |
349 | * send messages even if no memory is available. This is subject to | |
350 | * change as the system changes, so don't use it unless you REALLY | |
351 | * have to. | |
352 | */ | |
353 | int ipmi_request_supply_msgs(ipmi_user_t user, | |
354 | struct ipmi_addr *addr, | |
355 | long msgid, | |
356 | struct kernel_ipmi_msg *msg, | |
357 | void *user_msg_data, | |
358 | void *supplied_smi, | |
359 | struct ipmi_recv_msg *supplied_recv, | |
360 | int priority); | |
361 | ||
fcfa4724 CM |
362 | /* |
363 | * Poll the IPMI interface for the user. This causes the IPMI code to | |
364 | * do an immediate check for information from the driver and handle | |
365 | * anything that is immediately pending. This will not block in any | |
bda4c30a CM |
366 | * way. This is useful if you need to spin waiting for something to |
367 | * happen in the IPMI driver. | |
fcfa4724 CM |
368 | */ |
369 | void ipmi_poll_interface(ipmi_user_t user); | |
370 | ||
1da177e4 LT |
371 | /* |
372 | * When commands come in to the SMS, the user can register to receive | |
c69c3127 | 373 | * them. Only one user can be listening on a specific netfn/cmd/chan tuple |
1da177e4 LT |
374 | * at a time, you will get an EBUSY error if the command is already |
375 | * registered. If a command is received that does not have a user | |
376 | * registered, the driver will automatically return the proper | |
c69c3127 CM |
377 | * error. Channels are specified as a bitfield, use IPMI_CHAN_ALL to |
378 | * mean all channels. | |
1da177e4 LT |
379 | */ |
380 | int ipmi_register_for_cmd(ipmi_user_t user, | |
381 | unsigned char netfn, | |
c69c3127 CM |
382 | unsigned char cmd, |
383 | unsigned int chans); | |
1da177e4 LT |
384 | int ipmi_unregister_for_cmd(ipmi_user_t user, |
385 | unsigned char netfn, | |
c69c3127 CM |
386 | unsigned char cmd, |
387 | unsigned int chans); | |
1da177e4 | 388 | |
b9675136 CM |
389 | /* |
390 | * Go into a mode where the driver will not autonomously attempt to do | |
391 | * things with the interface. It will still respond to attentions and | |
392 | * interrupts, and it will expect that commands will complete. It | |
393 | * will not automatcially check for flags, events, or things of that | |
394 | * nature. | |
395 | * | |
396 | * This is primarily used for firmware upgrades. The idea is that | |
397 | * when you go into firmware upgrade mode, you do this operation | |
398 | * and the driver will not attempt to do anything but what you tell | |
399 | * it or what the BMC asks for. | |
400 | * | |
401 | * Note that if you send a command that resets the BMC, the driver | |
402 | * will still expect a response from that command. So the BMC should | |
403 | * reset itself *after* the response is sent. Resetting before the | |
404 | * response is just silly. | |
405 | * | |
406 | * If in auto maintenance mode, the driver will automatically go into | |
407 | * maintenance mode for 30 seconds if it sees a cold reset, a warm | |
408 | * reset, or a firmware NetFN. This means that code that uses only | |
409 | * firmware NetFN commands to do upgrades will work automatically | |
410 | * without change, assuming it sends a message every 30 seconds or | |
411 | * less. | |
412 | * | |
413 | * See the IPMI_MAINTENANCE_MODE_xxx defines for what the mode means. | |
414 | */ | |
415 | int ipmi_get_maintenance_mode(ipmi_user_t user); | |
416 | int ipmi_set_maintenance_mode(ipmi_user_t user, int mode); | |
417 | ||
1da177e4 LT |
418 | /* |
419 | * When the user is created, it will not receive IPMI events by | |
420 | * default. The user must set this to TRUE to get incoming events. | |
421 | * The first user that sets this to TRUE will receive all events that | |
422 | * have been queued while no one was waiting for events. | |
423 | */ | |
424 | int ipmi_set_gets_events(ipmi_user_t user, int val); | |
425 | ||
426 | /* | |
427 | * Called when a new SMI is registered. This will also be called on | |
428 | * every existing interface when a new watcher is registered with | |
429 | * ipmi_smi_watcher_register(). | |
430 | */ | |
c70d7499 | 431 | struct ipmi_smi_watcher { |
1da177e4 LT |
432 | struct list_head link; |
433 | ||
434 | /* You must set the owner to the current module, if you are in | |
435 | a module (generally just set it to "THIS_MODULE"). */ | |
436 | struct module *owner; | |
437 | ||
438 | /* These two are called with read locks held for the interface | |
439 | the watcher list. So you can add and remove users from the | |
440 | IPMI interface, send messages, etc., but you cannot add | |
441 | or remove SMI watchers or SMI interfaces. */ | |
50c812b2 | 442 | void (*new_smi)(int if_num, struct device *dev); |
1da177e4 LT |
443 | void (*smi_gone)(int if_num); |
444 | }; | |
445 | ||
446 | int ipmi_smi_watcher_register(struct ipmi_smi_watcher *watcher); | |
447 | int ipmi_smi_watcher_unregister(struct ipmi_smi_watcher *watcher); | |
448 | ||
449 | /* The following are various helper functions for dealing with IPMI | |
450 | addresses. */ | |
451 | ||
452 | /* Return the maximum length of an IPMI address given it's type. */ | |
453 | unsigned int ipmi_addr_length(int addr_type); | |
454 | ||
455 | /* Validate that the given IPMI address is valid. */ | |
456 | int ipmi_validate_addr(struct ipmi_addr *addr, int len); | |
457 | ||
16f4232c ZY |
458 | /* |
459 | * How did the IPMI driver find out about the device? | |
460 | */ | |
461 | enum ipmi_addr_src { | |
462 | SI_INVALID = 0, SI_HOTMOD, SI_HARDCODED, SI_SPMI, SI_ACPI, SI_SMBIOS, | |
463 | SI_PCI, SI_DEVICETREE, SI_DEFAULT | |
464 | }; | |
465 | ||
466 | union ipmi_smi_info_union { | |
467 | /* | |
468 | * the acpi_info element is defined for the SI_ACPI | |
469 | * address type | |
470 | */ | |
471 | struct { | |
472 | void *acpi_handle; | |
473 | } acpi_info; | |
474 | }; | |
475 | ||
476 | struct ipmi_smi_info { | |
477 | enum ipmi_addr_src addr_src; | |
478 | ||
479 | /* | |
480 | * Base device for the interface. Don't forget to put this when | |
481 | * you are done. | |
482 | */ | |
483 | struct device *dev; | |
484 | ||
485 | /* | |
486 | * The addr_info provides more detailed info for some IPMI | |
487 | * devices, depending on the addr_src. Currently only SI_ACPI | |
488 | * info is provided. | |
489 | */ | |
490 | union ipmi_smi_info_union addr_info; | |
491 | }; | |
492 | ||
493 | /* This is to get the private info of ipmi_smi_t */ | |
494 | extern int ipmi_get_smi_info(int if_num, struct ipmi_smi_info *data); | |
495 | ||
1da177e4 LT |
496 | #endif /* __KERNEL__ */ |
497 | ||
498 | ||
499 | /* | |
500 | * The userland interface | |
501 | */ | |
502 | ||
503 | /* | |
504 | * The userland interface for the IPMI driver is a standard character | |
505 | * device, with each instance of an interface registered as a minor | |
506 | * number under the major character device. | |
507 | * | |
508 | * The read and write calls do not work, to get messages in and out | |
509 | * requires ioctl calls because of the complexity of the data. select | |
510 | * and poll do work, so you can wait for input using the file | |
511 | * descriptor, you just can use read to get it. | |
512 | * | |
513 | * In general, you send a command down to the interface and receive | |
514 | * responses back. You can use the msgid value to correlate commands | |
515 | * and responses, the driver will take care of figuring out which | |
516 | * incoming messages are for which command and find the proper msgid | |
517 | * value to report. You will only receive reponses for commands you | |
518 | * send. Asynchronous events, however, go to all open users, so you | |
519 | * must be ready to handle these (or ignore them if you don't care). | |
520 | * | |
521 | * The address type depends upon the channel type. When talking | |
522 | * directly to the BMC (IPMC_BMC_CHANNEL), the address is ignored | |
523 | * (IPMI_UNUSED_ADDR_TYPE). When talking to an IPMB channel, you must | |
524 | * supply a valid IPMB address with the addr_type set properly. | |
525 | * | |
526 | * When talking to normal channels, the driver takes care of the | |
527 | * details of formatting and sending messages on that channel. You do | |
528 | * not, for instance, have to format a send command, you just send | |
529 | * whatever command you want to the channel, the driver will create | |
530 | * the send command, automatically issue receive command and get even | |
531 | * commands, and pass those up to the proper user. | |
532 | */ | |
533 | ||
534 | ||
535 | /* The magic IOCTL value for this interface. */ | |
536 | #define IPMI_IOC_MAGIC 'i' | |
537 | ||
538 | ||
539 | /* Messages sent to the interface are this format. */ | |
c70d7499 | 540 | struct ipmi_req { |
1da177e4 LT |
541 | unsigned char __user *addr; /* Address to send the message to. */ |
542 | unsigned int addr_len; | |
543 | ||
544 | long msgid; /* The sequence number for the message. This | |
545 | exact value will be reported back in the | |
546 | response to this request if it is a command. | |
547 | If it is a response, this will be used as | |
548 | the sequence value for the response. */ | |
549 | ||
550 | struct ipmi_msg msg; | |
551 | }; | |
552 | /* | |
553 | * Send a message to the interfaces. error values are: | |
554 | * - EFAULT - an address supplied was invalid. | |
555 | * - EINVAL - The address supplied was not valid, or the command | |
556 | * was not allowed. | |
557 | * - EMSGSIZE - The message to was too large. | |
558 | * - ENOMEM - Buffers could not be allocated for the command. | |
559 | */ | |
560 | #define IPMICTL_SEND_COMMAND _IOR(IPMI_IOC_MAGIC, 13, \ | |
561 | struct ipmi_req) | |
562 | ||
563 | /* Messages sent to the interface with timing parameters are this | |
564 | format. */ | |
c70d7499 | 565 | struct ipmi_req_settime { |
1da177e4 LT |
566 | struct ipmi_req req; |
567 | ||
568 | /* See ipmi_request_settime() above for details on these | |
c70d7499 | 569 | values. */ |
1da177e4 LT |
570 | int retries; |
571 | unsigned int retry_time_ms; | |
572 | }; | |
573 | /* | |
574 | * Send a message to the interfaces with timing parameters. error values | |
575 | * are: | |
576 | * - EFAULT - an address supplied was invalid. | |
577 | * - EINVAL - The address supplied was not valid, or the command | |
578 | * was not allowed. | |
579 | * - EMSGSIZE - The message to was too large. | |
580 | * - ENOMEM - Buffers could not be allocated for the command. | |
581 | */ | |
582 | #define IPMICTL_SEND_COMMAND_SETTIME _IOR(IPMI_IOC_MAGIC, 21, \ | |
583 | struct ipmi_req_settime) | |
584 | ||
585 | /* Messages received from the interface are this format. */ | |
c70d7499 | 586 | struct ipmi_recv { |
1da177e4 LT |
587 | int recv_type; /* Is this a command, response or an |
588 | asyncronous event. */ | |
589 | ||
590 | unsigned char __user *addr; /* Address the message was from is put | |
591 | here. The caller must supply the | |
592 | memory. */ | |
593 | unsigned int addr_len; /* The size of the address buffer. | |
594 | The caller supplies the full buffer | |
595 | length, this value is updated to | |
596 | the actual message length when the | |
597 | message is received. */ | |
598 | ||
599 | long msgid; /* The sequence number specified in the request | |
600 | if this is a response. If this is a command, | |
601 | this will be the sequence number from the | |
602 | command. */ | |
603 | ||
604 | struct ipmi_msg msg; /* The data field must point to a buffer. | |
605 | The data_size field must be set to the | |
606 | size of the message buffer. The | |
607 | caller supplies the full buffer | |
608 | length, this value is updated to the | |
609 | actual message length when the message | |
610 | is received. */ | |
611 | }; | |
612 | ||
613 | /* | |
614 | * Receive a message. error values: | |
615 | * - EAGAIN - no messages in the queue. | |
616 | * - EFAULT - an address supplied was invalid. | |
617 | * - EINVAL - The address supplied was not valid. | |
618 | * - EMSGSIZE - The message to was too large to fit into the message buffer, | |
619 | * the message will be left in the buffer. */ | |
620 | #define IPMICTL_RECEIVE_MSG _IOWR(IPMI_IOC_MAGIC, 12, \ | |
621 | struct ipmi_recv) | |
622 | ||
623 | /* | |
624 | * Like RECEIVE_MSG, but if the message won't fit in the buffer, it | |
625 | * will truncate the contents instead of leaving the data in the | |
626 | * buffer. | |
627 | */ | |
628 | #define IPMICTL_RECEIVE_MSG_TRUNC _IOWR(IPMI_IOC_MAGIC, 11, \ | |
629 | struct ipmi_recv) | |
630 | ||
631 | /* Register to get commands from other entities on this interface. */ | |
c70d7499 | 632 | struct ipmi_cmdspec { |
1da177e4 LT |
633 | unsigned char netfn; |
634 | unsigned char cmd; | |
635 | }; | |
636 | ||
c70d7499 | 637 | /* |
1da177e4 LT |
638 | * Register to receive a specific command. error values: |
639 | * - EFAULT - an address supplied was invalid. | |
640 | * - EBUSY - The netfn/cmd supplied was already in use. | |
641 | * - ENOMEM - could not allocate memory for the entry. | |
642 | */ | |
643 | #define IPMICTL_REGISTER_FOR_CMD _IOR(IPMI_IOC_MAGIC, 14, \ | |
644 | struct ipmi_cmdspec) | |
645 | /* | |
646 | * Unregister a regsitered command. error values: | |
647 | * - EFAULT - an address supplied was invalid. | |
648 | * - ENOENT - The netfn/cmd was not found registered for this user. | |
649 | */ | |
650 | #define IPMICTL_UNREGISTER_FOR_CMD _IOR(IPMI_IOC_MAGIC, 15, \ | |
651 | struct ipmi_cmdspec) | |
652 | ||
c69c3127 CM |
653 | /* |
654 | * Register to get commands from other entities on specific channels. | |
655 | * This way, you can only listen on specific channels, or have messages | |
656 | * from some channels go to one place and other channels to someplace | |
657 | * else. The chans field is a bitmask, (1 << channel) for each channel. | |
658 | * It may be IPMI_CHAN_ALL for all channels. | |
659 | */ | |
c70d7499 | 660 | struct ipmi_cmdspec_chans { |
c69c3127 CM |
661 | unsigned int netfn; |
662 | unsigned int cmd; | |
663 | unsigned int chans; | |
664 | }; | |
665 | ||
666 | /* | |
667 | * Register to receive a specific command on specific channels. error values: | |
668 | * - EFAULT - an address supplied was invalid. | |
669 | * - EBUSY - One of the netfn/cmd/chans supplied was already in use. | |
670 | * - ENOMEM - could not allocate memory for the entry. | |
671 | */ | |
672 | #define IPMICTL_REGISTER_FOR_CMD_CHANS _IOR(IPMI_IOC_MAGIC, 28, \ | |
673 | struct ipmi_cmdspec_chans) | |
674 | /* | |
675 | * Unregister some netfn/cmd/chans. error values: | |
676 | * - EFAULT - an address supplied was invalid. | |
677 | * - ENOENT - None of the netfn/cmd/chans were found registered for this user. | |
678 | */ | |
679 | #define IPMICTL_UNREGISTER_FOR_CMD_CHANS _IOR(IPMI_IOC_MAGIC, 29, \ | |
680 | struct ipmi_cmdspec_chans) | |
681 | ||
c70d7499 | 682 | /* |
1da177e4 LT |
683 | * Set whether this interface receives events. Note that the first |
684 | * user registered for events will get all pending events for the | |
685 | * interface. error values: | |
686 | * - EFAULT - an address supplied was invalid. | |
687 | */ | |
688 | #define IPMICTL_SET_GETS_EVENTS_CMD _IOR(IPMI_IOC_MAGIC, 16, int) | |
689 | ||
690 | /* | |
691 | * Set and get the slave address and LUN that we will use for our | |
692 | * source messages. Note that this affects the interface, not just | |
693 | * this user, so it will affect all users of this interface. This is | |
694 | * so some initialization code can come in and do the OEM-specific | |
695 | * things it takes to determine your address (if not the BMC) and set | |
696 | * it for everyone else. You should probably leave the LUN alone. | |
697 | */ | |
c70d7499 | 698 | struct ipmi_channel_lun_address_set { |
c14979b9 CM |
699 | unsigned short channel; |
700 | unsigned char value; | |
701 | }; | |
c70d7499 CM |
702 | #define IPMICTL_SET_MY_CHANNEL_ADDRESS_CMD \ |
703 | _IOR(IPMI_IOC_MAGIC, 24, struct ipmi_channel_lun_address_set) | |
704 | #define IPMICTL_GET_MY_CHANNEL_ADDRESS_CMD \ | |
705 | _IOR(IPMI_IOC_MAGIC, 25, struct ipmi_channel_lun_address_set) | |
706 | #define IPMICTL_SET_MY_CHANNEL_LUN_CMD \ | |
707 | _IOR(IPMI_IOC_MAGIC, 26, struct ipmi_channel_lun_address_set) | |
708 | #define IPMICTL_GET_MY_CHANNEL_LUN_CMD \ | |
709 | _IOR(IPMI_IOC_MAGIC, 27, struct ipmi_channel_lun_address_set) | |
c14979b9 | 710 | /* Legacy interfaces, these only set IPMB 0. */ |
1da177e4 LT |
711 | #define IPMICTL_SET_MY_ADDRESS_CMD _IOR(IPMI_IOC_MAGIC, 17, unsigned int) |
712 | #define IPMICTL_GET_MY_ADDRESS_CMD _IOR(IPMI_IOC_MAGIC, 18, unsigned int) | |
713 | #define IPMICTL_SET_MY_LUN_CMD _IOR(IPMI_IOC_MAGIC, 19, unsigned int) | |
714 | #define IPMICTL_GET_MY_LUN_CMD _IOR(IPMI_IOC_MAGIC, 20, unsigned int) | |
715 | ||
716 | /* | |
717 | * Get/set the default timing values for an interface. You shouldn't | |
718 | * generally mess with these. | |
719 | */ | |
c70d7499 | 720 | struct ipmi_timing_parms { |
1da177e4 LT |
721 | int retries; |
722 | unsigned int retry_time_ms; | |
723 | }; | |
724 | #define IPMICTL_SET_TIMING_PARMS_CMD _IOR(IPMI_IOC_MAGIC, 22, \ | |
725 | struct ipmi_timing_parms) | |
726 | #define IPMICTL_GET_TIMING_PARMS_CMD _IOR(IPMI_IOC_MAGIC, 23, \ | |
727 | struct ipmi_timing_parms) | |
728 | ||
b9675136 CM |
729 | /* |
730 | * Set the maintenance mode. See ipmi_set_maintenance_mode() above | |
731 | * for a description of what this does. | |
732 | */ | |
733 | #define IPMICTL_GET_MAINTENANCE_MODE_CMD _IOR(IPMI_IOC_MAGIC, 30, int) | |
734 | #define IPMICTL_SET_MAINTENANCE_MODE_CMD _IOW(IPMI_IOC_MAGIC, 31, int) | |
735 | ||
1da177e4 | 736 | #endif /* __LINUX_IPMI_H */ |