1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 /*
30 * This is utility library that provides APIs to interact with SMC driver
31 */
32
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <sys/stat.h>
36 #include <fcntl.h>
37 #include <poll.h>
38 #include <assert.h>
39 #include <unistd.h>
40 #include <string.h>
41 #include <strings.h>
42 #include <stdarg.h>
43 #include <stropts.h>
44 #include <syslog.h>
45 #include "smclib.h"
46
47 static int debug_on = 0;
48
49 /* Error messages */
50 #define SMC_ERRMSG_OPEN "SMC open failed, cmd = %x\n"
51 #define SMC_ERRMSG_WRITE "SMC write failed, cmd = %x\n"
52 #define SMC_ERRMSG_POLLTIMEOUT "SMC poll timed out, cmd = %x\n"
53 #define SMC_ERRMSG_POLLFAILED "SMC poll failed, cmd = %x\n"
54 #define SMC_ERRMSG_POLL_T "SMC poll timed out, dest = %x\n"
55 #define SMC_ERRMSG_POLL_F "SMC poll failed, dest = %x\n"
56 #define SMC_ERRMSG_READ "SMC read response failed, cmd = %x\n"
57 #define SMC_ERRMSG_ERROR "SMC error, cc = %d, msg_id = %x\n"
58 #define SMC_ERRMSG_SETATTR "SMC setting read attribute failed\n"
59 #define SMC_ERRMSG_GET_SEQN "SMC error in getting seqn for %x\n"
60 #define SMC_ERRMSG_IPMI_ERR "SMC IPMI invalid cc:%x, dest = %x\n"
61 #define SMC_ERRMSG_GET_GEO "SMC get GeoAddr failed\n"
62
63 /* Macros */
64 #define REQ_SA(_X) (((_X) < 10) ? (0xb0 + 2 * ((_X) - 1)) :\
65 (0xb0 + 2 * (_X)))
66 #define LUN_BITMASK 0x03 /* last two bits */
67 #define RESPONSE_MSG 0x01 /* last bit */
68
69 #define SMC_LOCAL_SEQ_NO 10
70 #define SMC_POLL_TIME 1000 /* 1 sec */
71 #define NORMAL_COMPLETION_CODE 0
72 #define IPMI_MSG_CHANNEL_0 0x0
73 #define IPMI_REQ_HDR_LEN 0x8 /* includes command & data checksum */
74 #define IPMI_RSP_HDR_LEN 0x8
75 #define SMC_NETFN_SEQ_OFFSET 5
76 #define SMC_CMD_OFFSET 6
77
78 #define SMC_NODE ("/dev/ctsmc")
79 #define DEFAULT_FD -1
80 #define DEFAULT_SEQN 128
81
82 /*
83 * IPMI packet header
84 */
85 typedef struct {
86 uint8_t channel_no; /* channel num */
87 uint8_t rs_addr; /* dest addr */
88 uint8_t netfn_lun; /* netfn and lun */
89 uint8_t checksum; /* checksum for dest and netfn_lun */
90 uint8_t rq_addr; /* sender addr */
91 uint8_t seq_num; /* sequence number */
92 uint8_t cmd; /* ipmi cmd */
93 } smc_ipmi_header_t;
94
95 /*
96 * debug printf
97 */
98 static void
99 dbg_print(const char *fmt, ...)
100 {
101 if (debug_on > 0) {
102 va_list ap;
103 va_start(ap, fmt);
104 (void) vprintf(fmt, ap);
105 va_end(ap);
106 }
107 }
108
109 /*
110 * send a local command to SMC
111 */
112 static smc_errno_t
113 smc_send_local_cmd(int fd, sc_reqmsg_t *req_pkt, sc_rspmsg_t *rsp_pkt,
114 int poll_time)
115 {
116 int poll_rc;
117 struct pollfd poll_fds[1];
118
119 poll_fds[0].fd = fd;
120 poll_fds[0].events = POLLIN|POLLPRI;
121 poll_fds[0].revents = 0;
122
123 /* send the command to SMC */
124 if (write(fd, req_pkt, SC_SEND_HEADER + SC_MSG_LEN(req_pkt)) < 0) {
125 dbg_print(SMC_ERRMSG_WRITE, SC_MSG_CMD(req_pkt));
126 return (SMC_REQ_FAILURE);
127 }
128
129 poll_rc = poll(poll_fds, 1, poll_time);
130 if (poll_rc == 0) {
131 dbg_print(SMC_ERRMSG_POLLTIMEOUT, SC_MSG_CMD(req_pkt));
132 return (SMC_ACK_FAILURE);
133 } else if (poll_rc == -1) {
134 dbg_print(SMC_ERRMSG_POLLFAILED, SC_MSG_CMD(req_pkt));
135 return (SMC_ACK_FAILURE);
136 }
137
138 /* read the response from SMC */
139 if (read(fd, rsp_pkt, SC_MSG_MAX_SIZE) == -1) {
140 dbg_print(SMC_ERRMSG_READ, SC_MSG_CMD(req_pkt));
141 return (SMC_ACK_FAILURE);
142 }
143
144 /* check if response is valid */
145 if (SC_MSG_ID(rsp_pkt) != SC_MSG_ID(req_pkt)) {
146 dbg_print(SMC_ERRMSG_ERROR, SC_MSG_CC(rsp_pkt),
147 SC_MSG_ID(rsp_pkt));
148 return (SMC_INVALID_SEQ);
149 }
150
151 if (SC_MSG_CC(rsp_pkt) != 0) {
152 return (SMC_FAILURE);
153 }
154
155 return (SMC_SUCCESS);
156 }
157
158 /*
159 * get_geo_addr -- returns the geographical address of a CPU board
160 */
161 static int
162 get_geo_addr(uint8_t *geo_addr)
163 {
164 int fd, rc;
165 sc_reqmsg_t req_pkt;
166 sc_rspmsg_t rsp_pkt;
167
168 if ((fd = open(SMC_NODE, O_RDWR)) < 0) {
169 dbg_print(SMC_ERRMSG_OPEN,
170 SMC_GET_GEOGRAPHICAL_ADDRESS);
171 return (SMC_FAILURE);
172 }
173
174 SC_MSG_CMD(&req_pkt) = SMC_GET_GEOGRAPHICAL_ADDRESS;
175 SC_MSG_LEN(&req_pkt) = 0;
176 SC_MSG_ID(&req_pkt) = SMC_LOCAL_SEQ_NO;
177
178 /* no request data */
179 if ((rc = smc_send_local_cmd(fd, &req_pkt, &rsp_pkt,
180 SMC_POLL_TIME)) != SMC_SUCCESS) {
181 (void) close(fd);
182 return (rc);
183 }
184
185 *geo_addr = rsp_pkt.data[0];
186 (void) close(fd);
187 return (SMC_SUCCESS);
188 }
189
190 /*
191 * checksum - returns a 2-complement check sum
192 */
193 static uint8_t
194 checksum(uint8_t buf[], int start, int end)
195 {
196 int i;
197 uint8_t sum = 0x0;
198
199 for (i = start; i <= end; i++) {
200 sum += buf[i];
201 }
202 sum = ~sum + 1;
203 return (sum);
204 }
205
206 /*
207 * func to send IPMI messages
208 */
209 static smc_errno_t
210 smc_send_ipmi_message(int fd, sc_reqmsg_t *req_pkt, sc_rspmsg_t *rsp_pkt,
211 int poll_time)
212 {
213 int result, nbytes, i = 0;
214 struct pollfd fds;
215 uint8_t cc, netfn;
216 boolean_t is_response = B_FALSE;
217 char data[SC_MSG_MAX_SIZE], *p;
218
219 if (debug_on) {
220 bzero(data, SC_MSG_MAX_SIZE);
221 p = data;
222 for (i = 0; i < SC_MSG_LEN(req_pkt); i++) {
223 (void) sprintf(p, "%02x ", req_pkt->data[i]);
224 p = data + strlen(data);
225 }
226 p = data;
227 syslog(LOG_ERR, "REQ> %s", p);
228 }
229
230 netfn = req_pkt->data[2] >> 2;
231 if (netfn & RESPONSE_MSG) {
232 is_response = B_TRUE;
233 }
234
235 if ((nbytes = write(fd, (char *)req_pkt, SC_SEND_HEADER +
236 SC_MSG_LEN(req_pkt))) < 0) {
237 dbg_print(SMC_ERRMSG_WRITE, SMC_SEND_MESSAGE);
238 return (SMC_REQ_FAILURE);
239 }
240
241 if ((nbytes = read(fd, (char *)rsp_pkt, SC_MSG_MAX_SIZE)) < 0) {
242 dbg_print(SMC_ERRMSG_READ, SMC_SEND_MESSAGE);
243 return (SMC_ACK_FAILURE);
244 }
245
246 if (SC_MSG_CC(rsp_pkt) != 0) {
247 dbg_print(SMC_ERRMSG_ERROR, SC_MSG_CC(rsp_pkt),
248 SC_MSG_ID(rsp_pkt));
249 return (SMC_ACK_FAILURE);
250 }
251
252 if (is_response) { /* need not wait for response */
253 return (SMC_SUCCESS);
254 }
255
256 fds.fd = fd;
257 fds.events = POLLIN | POLLPRI;
258 fds.revents = 0;
259 result = poll(&fds, 1, poll_time);
260
261 if (result == 0) {
262 dbg_print(SMC_ERRMSG_POLL_T, req_pkt->data[1]);
263 return (SMC_RSP_TIMEOUT);
264 } else if (result < 0) {
265 dbg_print(SMC_ERRMSG_POLL_F, req_pkt->data[1]);
266 return (SMC_RSP_ERROR);
267 }
268
269 nbytes = read(fd, rsp_pkt, SC_MSG_MAX_SIZE);
270 if (nbytes < 0) {
271 dbg_print(SMC_ERRMSG_READ, SMC_SEND_MESSAGE);
272 return (SMC_RSP_ERROR);
273 }
274
275 if (debug_on) {
276 bzero(data, SC_MSG_MAX_SIZE);
277 p = data;
278 for (i = 0; i < nbytes; i++) {
279 (void) sprintf(p, "%02x ", rsp_pkt->data[i]);
280 p = data + strlen(data);
281 }
282 p = data;
283 syslog(LOG_DEBUG, "RES> %s, seq = %x, cmd = %x, len = %x,"
284 "cc = %x", p, SC_MSG_ID(rsp_pkt), SC_MSG_CMD(rsp_pkt),
285 SC_MSG_LEN(rsp_pkt), SC_MSG_CC(rsp_pkt));
286 }
287
288 if (SC_MSG_CC(rsp_pkt) != 0) {
289 dbg_print(SMC_ERRMSG_IPMI_ERR, rsp_pkt->hdr.cc,
290 req_pkt->data[SMC_CMD_OFFSET]);
291 return (SMC_RSP_ERROR);
292 }
293
294 if (req_pkt->data[SMC_NETFN_SEQ_OFFSET] !=
295 rsp_pkt->data[SMC_NETFN_SEQ_OFFSET]) {
296 dbg_print("SMC: Invalid sequence number in"
297 " IPMI Response (sent %x, received %x)\n",
298 req_pkt->data[5], rsp_pkt->data[SMC_NETFN_SEQ_OFFSET]);
299 }
300
301 if ((cc = rsp_pkt->data[IPMI_RSP_HDR_LEN-1]) != 0) {
302 dbg_print("SMC:IPMI response completion "
303 "error %x, command = %x\n",
304 cc, req_pkt->data[SMC_CMD_OFFSET]);
305 }
306 return (SMC_SUCCESS);
307 }
308
309 /*
310 * Initializes the IPMI request packet
311 */
312 smc_errno_t
313 smc_init_ipmi_msg(sc_reqmsg_t *req_msg, uint8_t cmd, uint8_t msg_id,
314 uint8_t msg_data_size, uint8_t *msg_data_buf, int8_t seq_num,
315 int ipmb_addr, smc_netfn_t netfn, smc_lun_t lun)
316 {
317 static uint8_t geo_addr = 0;
318 smc_ipmi_header_t ipmi_header;
319 uint8_t data[2];
320 if (msg_data_size > 0) {
321 if ((msg_data_size > (SC_SEND_DSIZE - IPMI_REQ_HDR_LEN)) ||
322 (msg_data_buf == NULL)) {
323 return (SMC_FAILURE);
324 }
325 }
326
327 /* get the geo addr for first time */
328 if (geo_addr == 0) {
329 if (get_geo_addr(&geo_addr) != SMC_SUCCESS) {
330 dbg_print(SMC_ERRMSG_GET_GEO);
331 return (SMC_FAILURE);
332 }
333 }
334
335 SC_MSG_CMD(req_msg) = SMC_SEND_MESSAGE;
336 SC_MSG_ID(req_msg) = msg_id;
337 SC_MSG_LEN(req_msg) = IPMI_REQ_HDR_LEN + msg_data_size;
338 ipmi_header.channel_no = IPMI_MSG_CHANNEL_0;
339 ipmi_header.rs_addr = data[0] = ipmb_addr;
340 ipmi_header.netfn_lun = data[1] = (netfn << 2) | lun;
341 ipmi_header.checksum = checksum(data, 0, 1);
342 ipmi_header.rq_addr = REQ_SA(geo_addr);
343 ipmi_header.cmd = cmd;
344 if (seq_num >= 0 && seq_num < 64) {
345 ipmi_header.seq_num = (seq_num << 2) | SMC_SMS_LUN;
346 } else {
347 ipmi_header.seq_num = DEFAULT_SEQN;
348 }
349
350 /* copy the header */
351 (void) bcopy((void *)&ipmi_header, SC_MSG_DATA(req_msg),
352 sizeof (ipmi_header));
353
354 /* copy the msg data into request packet */
355 (void) bcopy((void *)msg_data_buf, (void *)((uchar_t *)req_msg->data +
356 (IPMI_REQ_HDR_LEN - 1)), msg_data_size);
357 return (SMC_SUCCESS);
358 }
359
360 /*
361 * Initialize a SMC packet
362 */
363 smc_errno_t
364 smc_init_smc_msg(sc_reqmsg_t *req_msg, smc_app_command_t cmd,
365 uint8_t msg_id, uint8_t msg_data_size)
366 {
367 if (msg_data_size > SC_SEND_DSIZE) {
368 return (SMC_FAILURE);
369 }
370
371 /* fill the packet */
372 SC_MSG_CMD(req_msg) = cmd;
373 SC_MSG_LEN(req_msg) = msg_data_size;
374 SC_MSG_ID(req_msg) = msg_id;
375 return (SMC_SUCCESS);
376 }
377
378 /*
379 * Sends SMC(local) and IPMI messages
380 */
381 smc_errno_t
382 smc_send_msg(int fd, sc_reqmsg_t *req_msg, sc_rspmsg_t *rsp_msg,
383 int poll_time)
384 {
385 int rc = SMC_SUCCESS;
386 uint8_t dsize, dest;
387 boolean_t close_fd = B_FALSE;
388 boolean_t free_seqn = B_FALSE;
389 struct strioctl scioc;
390 sc_seqdesc_t smc_seq;
391 int8_t seq_no;
392
393 if (req_msg == NULL || rsp_msg == NULL) {
394 return (SMC_FAILURE);
395 }
396
397 if (fd < 0) {
398 close_fd = B_TRUE;
399 if ((fd = open(SMC_NODE, O_RDWR)) < 0) {
400 dbg_print(SMC_ERRMSG_OPEN,
401 SC_MSG_CMD(req_msg));
402 return (SMC_FAILURE);
403 }
404 }
405
406 if (ioctl(fd, I_SRDOPT, RMSGD) < 0) {
407 dbg_print(SMC_ERRMSG_SETATTR);
408 if (close_fd)
409 (void) close(fd);
410 return (SMC_FAILURE);
411 }
412
413 if (SC_MSG_CMD(req_msg) != SMC_SEND_MESSAGE) {
414 rc = smc_send_local_cmd(fd, req_msg, rsp_msg, poll_time);
415 if (close_fd) {
416 (void) close(fd);
417 }
418 return (rc);
419 }
420
421 /* This is an IPMI message */
422 dsize = SC_MSG_LEN(req_msg) - IPMI_REQ_HDR_LEN;
423 if (dsize > (SC_SEND_DSIZE - IPMI_REQ_HDR_LEN)) {
424 if (close_fd) {
425 (void) close(fd);
426 }
427 return (SMC_FAILURE);
428 }
429
430 /* check if sequence num is valid or not */
431 if (req_msg->data[SMC_NETFN_SEQ_OFFSET] == DEFAULT_SEQN) {
432 free_seqn = B_TRUE;
433 bzero(&smc_seq, sizeof (sc_seqdesc_t));
434 dest = smc_seq.d_addr = req_msg->data[1]; /* dest */
435 smc_seq.n_seqn = 1;
436 smc_seq.seq_numbers[0] = 0;
437 scioc.ic_cmd = SCIOC_RESERVE_SEQN;
438 scioc.ic_timout = 0;
439 scioc.ic_len = sizeof (sc_seqdesc_t);
440 scioc.ic_dp = (char *)&smc_seq;
441 if (ioctl(fd, I_STR, &scioc) < 0) {
442 dbg_print(SMC_ERRMSG_GET_SEQN, dest);
443 if (close_fd) {
444 (void) close(fd);
445 }
446 return (SMC_FAILURE);
447 }
448 seq_no = smc_seq.seq_numbers[0];
449 req_msg->data[SMC_NETFN_SEQ_OFFSET] =
450 (seq_no << 2) | SMC_SMS_LUN;
451 }
452
453 req_msg->data[(IPMI_REQ_HDR_LEN-1)+dsize] =
454 checksum(req_msg->data, 4, (IPMI_REQ_HDR_LEN-2)+dsize);
455
456 rc = smc_send_ipmi_message(fd, req_msg, rsp_msg, poll_time);
457
458 if (free_seqn) { /* free seqn if library reserved it */
459 smc_seq.d_addr = dest;
460 smc_seq.n_seqn = 1;
461 smc_seq.seq_numbers[0] = seq_no;
462 scioc.ic_cmd = SCIOC_FREE_SEQN;
463 scioc.ic_timout = 0;
464 scioc.ic_len = sizeof (sc_seqdesc_t);
465 scioc.ic_dp = (char *)&smc_seq;
466 if (ioctl(fd, I_STR, &scioc) < 0) {
467 dbg_print("SMC:Error in releasing sequence "
468 "number\n");
469 rc = SMC_FAILURE;
470 }
471 }
472 if (close_fd) {
473 (void) close(fd);
474 }
475 return (rc);
476 }