?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel: remove unused utsname_set_machine()
[unleashed.git] / usr / src / uts / sun4v / ontario / io / tsalarm.c
bloba6585fa8d21cd57648d4a221475f44889f9f830a
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 (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26
27 #include <sys/types.h>
28 #include <sys/file.h>
29 #include <sys/errno.h>
30 #include <sys/open.h>
31 #include <sys/cred.h>
32 #include <sys/cmn_err.h>
33 #include <sys/modctl.h>
34 #include <sys/conf.h>
35 #include <sys/stat.h>
36
37 #include <sys/callb.h>
38 #include <sys/strlog.h>
39 #include <sys/lom_io.h>
40 #include <sys/time.h>
41 #include <sys/glvc.h>
42 #include <sys/kmem.h>
43 #include <netinet/in.h>
44 #include <sys/inttypes.h>
45
46 #include <sys/ddi.h>
47 #include <sys/sunddi.h>
48 #include <sys/sunldi.h>
49
50 /* common defines */
51 #ifndef MIN
52 #define MIN(x, y) ((x) < (y) ? (x) : (y))
53 #endif
54 #ifndef MAX
55 #define MAX(x, y) ((x) > (y) ? (x) : (y))
56 #endif
57 #ifndef ABS
58 #define ABS(x) ((x) < (0) ? (-(x)) : (x))
59 #endif
60
61 #define LOMIOCALCTL_OLD _IOW('a', 4, ts_aldata_t)
62 #define LOMIOCALSTATE_OLD _IOWR('a', 5, ts_aldata_t)
63
64 #define PCP_CKSUM_ENABLE
65 #define PCP_DEF_MTU_SZ 100
66
67 #define PCP_MAX_TRY_CNT 5
68 #define PCP_GLVC_SLEEP 5
69 #define PCP_COMM_TIMEOUT 0x10
70
71 #define PCP_IO_OP_READ (1)
72 #define PCP_IO_OP_WRITE (2)
73 #define PCP_IO_OP_PEEK (3)
74
75
76 /* Error codes for 'status' field in response message header */
77 #define TSAL_PCP_ERROR (-1)
78 #define TSAL_PCP_OK (0) /* message received okay */
79
80 /*
81 * magic number for Platform Channel Protocol (PCP)
82 * ~(rot13("PCP_") = 0xAFBCAFA0
83 * rot13 is a simple Caesar-cypher encryption that replaces each English letter
84 * with the one 13 places forward or back along the alphabet.
85 */
86 #define PCP_MAGIC_NUM (0xAFBCAFA0)
87
88 /* Platform channel protocol versions. */
89 #define PCP_PROT_VER_1 1
90
91 /* defines for 'timeout' */
92 #define PCP_TO_NO_RESPONSE (0xFFFFFFFF) /* no response required */
93 #define PCP_TO_WAIT_FOREVER (0) /* wait forever..(in reality, */
94 /* it waits until glvc driver */
95 /* call returns; curently glvc */
96 /* calls are blocking calls. */
97
98 /* Message Types */
99 #define PCP_ALARM_CONTROL 15
100 #define PCP_ALARM_CONTROL_R 16
101
102 /* alarm_action */
103 #define PCP_ALARM_ENABLE 1
104 #define PCP_ALARM_DISABLE 2
105 #define PCP_ALARM_STATUS 3
106
107 /* alarm_id */
108 #define PCP_ALARM_CRITICAL 0
109 #define PCP_ALARM_MAJOR 1
110 #define PCP_ALARM_MINOR 2
111 #define PCP_ALARM_USER 3
112
113 /* alarm_state */
114 #define ALARM_STATE_ON 1
115 #define ALARM_STATE_OFF 2
116 #define ALARM_STATE_UNKNOWN 3
117
118 /* Status Types */
119 #define PCP_ALARM_OK (1)
120 #define PCP_ALARM_ERROR (2)
121
122 /* tsalarm service channel */
123 #define ALARM_CHANNEL "/devices/virtual-devices@100/telco-alarm@f:glvc"
124
125 /* Driver state flags */
126 #define TSAL_OPENED 0x1
127 #define TSAL_IDENTED 0x2
128
129 /*
130 * Platform Channel Request Message Header.
131 */
132 typedef struct tsal_pcp_req_msg_hdr {
133 uint32_t magic_num; /* magic number */
134 uint8_t proto_ver; /* version info for */
135 /* backward compatibility */
136 uint8_t msg_type; /* provided by user apps */
137 uint8_t sub_type; /* provided by user apps */
138 uint8_t rsvd_pad; /* padding bits */
139 uint32_t xid; /* transaction id */
140 uint32_t timeout; /* timeout in seconds */
141 uint32_t msg_len; /* length of request or response data */
142 uint16_t msg_cksum; /* 16-bit checksum of req msg data */
143 uint16_t hdr_cksum; /* 16-bit checksum of req hdr */
144 } tsal_pcp_req_msg_hdr_t;
145
146 /*
147 * Platform Channel Response Message Header.
148 */
149 typedef struct tsal_pcp_resp_msg_hdr {
150 uint32_t magic_num; /* magic number */
151 uint8_t proto_ver; /* version info for */
152 /* backward compatibility */
153 uint8_t msg_type; /* passed to user apps */
154 uint8_t sub_type; /* passed to user apps */
155 uint8_t rsvd_pad; /* for padding */
156 uint32_t xid; /* transaction id */
157 uint32_t timeout; /* timeout in seconds */
158 uint32_t msg_len; /* length of request or response data */
159 uint32_t status; /* response status */
160 uint16_t msg_cksum; /* 16-bit checksum of resp msg data */
161 uint16_t hdr_cksum; /* 16-bit checksum of resp hdr */
162 } tsal_pcp_resp_msg_hdr_t;
163
164 /*
165 * PCP user apps message format
166 */
167 typedef struct tsal_pcp_msg {
168 uint8_t msg_type;
169 uint8_t sub_type;
170 uint16_t rsvd_pad;
171 uint32_t msg_len;
172 void *msg_data;
173 } tsal_pcp_msg_t;
174
175 /*
176 * alarm set/get request message
177 */
178 typedef struct tsal_pcp_alarm_req {
179 uint32_t alarm_id;
180 uint32_t alarm_action;
181 } tsal_pcp_alarm_req_t;
182
183 /*
184 * alarm set/get response message
185 */
186 typedef struct tsal_pcp_alarm_resp {
187 uint32_t status;
188 uint32_t alarm_id;
189 uint32_t alarm_state;
190 } tsal_pcp_alarm_resp_t;
191
192 /*
193 * tsalarm driver soft structure
194 */
195 typedef struct tsalarm_softc {
196 ldi_handle_t lh;
197 ldi_ident_t li;
198 dev_info_t *dip;
199 minor_t minor;
200 int flags;
201 kmutex_t mutex;
202 uint32_t msg_xid;
203 uint32_t mtu_size;
204 uint8_t *read_head;
205 uint8_t *read_tail;
206 uint8_t *read_area;
207 uint8_t *peek_area;
208 uint8_t *peek_read_area;
209 tsal_pcp_alarm_req_t *req_ptr;
210 tsal_pcp_alarm_resp_t *resp_ptr;
211 tsal_pcp_req_msg_hdr_t *req_msg_hdr;
212 tsal_pcp_resp_msg_hdr_t *resp_msg_hdr;
213 }tsalarm_softc_t;
214
215 /*
216 * Forward declarations.
217 */
218 static int tsal_pcp_send_req_msg_hdr(tsalarm_softc_t *sc,
219 tsal_pcp_req_msg_hdr_t *req_hdr);
220 static int tsal_pcp_recv_resp_msg_hdr(tsalarm_softc_t *sc,
221 tsal_pcp_resp_msg_hdr_t *resp_hdr);
222 static int tsal_pcp_io_op(tsalarm_softc_t *sc, void *buf,
223 int byte_cnt, int io_op);
224 static int tsal_pcp_read(tsalarm_softc_t *sc, uint8_t *buf, int buf_len);
225 static int tsal_pcp_write(tsalarm_softc_t *sc, uint8_t *buf, int buf_len);
226 static int tsal_pcp_peek(tsalarm_softc_t *sc, uint8_t *buf, int buf_len);
227 static int tsal_pcp_peek_read(tsalarm_softc_t *sc, uint8_t *buf, int buf_len);
228 static int tsal_pcp_frame_error_handle(tsalarm_softc_t *sc);
229 static int check_magic_byte_presence(tsalarm_softc_t *sc, int byte_cnt,
230 uint8_t *byte_val, int *ispresent);
231 static int tsal_pcp_send_recv(tsalarm_softc_t *sc, tsal_pcp_msg_t *req_msg,
232 tsal_pcp_msg_t *resp_msg, uint32_t timeout);
233 static uint32_t tsal_pcp_get_xid(tsalarm_softc_t *sc);
234 static uint16_t checksum(uint16_t *addr, int32_t count);
235 static int glvc_alarm_get(int alarm_type, int *alarm_state,
236 tsalarm_softc_t *sc);
237 static int glvc_alarm_set(int alarm_type, int new_state,
238 tsalarm_softc_t *sc);
239
240 #define getsoftc(minor) \
241 ((struct tsalarm_softc *)ddi_get_soft_state(statep, (minor)))
242
243 /*
244 * Driver entry points
245 */
246
247 /* dev_ops and cb_ops entry point function declarations */
248
249 static int tsalarm_attach(dev_info_t *, ddi_attach_cmd_t);
250 static int tsalarm_detach(dev_info_t *, ddi_detach_cmd_t);
251 static int tsalarm_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
252
253 static int tsalarm_open(dev_t *, int, int, cred_t *);
254 static int tsalarm_close(dev_t, int, int, cred_t *);
255 static int tsalarm_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
256
257 static struct cb_ops tsalarm_cb_ops = {
258 tsalarm_open, /* open */
259 tsalarm_close, /* close */
260 nodev, /* strategy() */
261 nodev, /* print() */
262 nodev, /* dump() */
263 nodev, /* read() */
264 nodev, /* write() */
265 tsalarm_ioctl, /* ioctl() */
266 nodev, /* devmap() */
267 nodev, /* mmap() */
268 ddi_segmap, /* segmap() */
269 nochpoll, /* poll() */
270 ddi_prop_op, /* prop_op() */
271 NULL, /* cb_str */
272 D_NEW | D_MP /* cb_flag */
273 };
274
275
276 static struct dev_ops tsalarm_ops = {
277 DEVO_REV,
278 0, /* ref count */
279 tsalarm_getinfo, /* getinfo() */
280 nulldev, /* identify() */
281 nulldev, /* probe() */
282 tsalarm_attach, /* attach() */
283 tsalarm_detach, /* detach */
284 nodev, /* reset */
285 &tsalarm_cb_ops, /* pointer to cb_ops structure */
286 NULL,
287 nulldev, /* power() */
288 ddi_quiesce_not_needed, /* quiesce() */
289 };
290
291 /*
292 * Loadable module support.
293 */
294 extern struct mod_ops mod_driverops;
295 static void *statep;
296
297 static struct modldrv modldrv = {
298 &mod_driverops, /* Type of module. This is a driver */
299 "tsalarm control driver", /* Name of the module */
300 &tsalarm_ops /* pointer to the dev_ops structure */
301 };
302
303 static struct modlinkage modlinkage = {
304 MODREV_1,
305 &modldrv,
306 NULL
307 };
308
309 int
310 _init(void)
311 {
312 int e;
313
314 if (e = ddi_soft_state_init(&statep,
315 sizeof (struct tsalarm_softc), 1)) {
316 return (e);
317 }
318
319 if ((e = mod_install(&modlinkage)) != 0) {
320 ddi_soft_state_fini(&statep);
321 }
322
323 return (e);
324 }
325
326 int
327 _fini(void)
328 {
329 int e;
330
331 if ((e = mod_remove(&modlinkage)) != 0) {
332 return (e);
333 }
334
335 ddi_soft_state_fini(&statep);
336
337 return (DDI_SUCCESS);
338 }
339
340 int
341 _info(struct modinfo *modinfop)
342 {
343 return (mod_info(&modlinkage, modinfop));
344 }
345
346
347 /* ARGSUSED */
348 static int
349 tsalarm_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
350 {
351 int inst = getminor((dev_t)arg);
352 int retval = DDI_SUCCESS;
353 struct tsalarm_softc *softc;
354
355 switch (cmd) {
356
357 case DDI_INFO_DEVT2DEVINFO:
358 if ((softc = getsoftc(inst)) == NULL) {
359 *result = NULL;
360 retval = DDI_FAILURE;
361 } else {
362 *result = (void *)softc->dip;
363 }
364 break;
365
366 case DDI_INFO_DEVT2INSTANCE:
367 *result = (void *)(uintptr_t)inst;
368 break;
369
370 default:
371 retval = DDI_FAILURE;
372 }
373
374 return (retval);
375 }
376
377 static int
378 tsalarm_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
379 {
380
381 int inst;
382 struct tsalarm_softc *softc = NULL;
383
384 switch (cmd) {
385
386 case DDI_ATTACH:
387 inst = ddi_get_instance(dip);
388 /*
389 * Allocate a soft state structure for this instance.
390 */
391 if (ddi_soft_state_zalloc(statep, inst) != DDI_SUCCESS) {
392 cmn_err(CE_WARN, "Failed to allocate memory");
393 goto attach_failed;
394 }
395
396 softc = getsoftc(inst);
397 softc->dip = dip;
398 softc->mtu_size = PCP_DEF_MTU_SZ;
399 softc->msg_xid = 0;
400 softc->read_area = NULL;
401 softc->read_head = NULL;
402 softc->read_tail = NULL;
403 softc->req_ptr = NULL;
404 softc->resp_ptr = NULL;
405
406 mutex_init(&softc->mutex, NULL, MUTEX_DRIVER, NULL);
407 /*
408 * Create minor node. The minor device number, inst, has no
409 * meaning. The model number above, which will be added to
410 * the device's softc, is used to direct peculiar behavior.
411 */
412 if (ddi_create_minor_node(dip, "lom", S_IFCHR, 0,
413 DDI_PSEUDO, NULL) == DDI_FAILURE) {
414 goto attach_failed;
415 }
416
417 ddi_report_dev(dip);
418 return (DDI_SUCCESS);
419
420 case DDI_RESUME:
421 return (DDI_SUCCESS);
422
423 default:
424 return (DDI_FAILURE);
425 }
426
427 attach_failed:
428 /* Free soft state, if allocated. remove minor node if added earlier */
429 if (softc) {
430 mutex_destroy(&softc->mutex);
431 ddi_soft_state_free(statep, inst);
432 }
433
434 ddi_remove_minor_node(dip, NULL);
435
436 return (DDI_FAILURE);
437 }
438
439 static int
440 tsalarm_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
441 {
442 int inst;
443 struct tsalarm_softc *softc;
444
445 switch (cmd) {
446
447 case DDI_DETACH:
448 inst = ddi_get_instance(dip);
449 if ((softc = getsoftc(inst)) == NULL)
450 return (DDI_FAILURE);
451 /*
452 * Free the soft state and remove minor node added earlier.
453 */
454 ddi_remove_minor_node(dip, NULL);
455 mutex_destroy(&softc->mutex);
456 ddi_soft_state_free(statep, inst);
457 return (DDI_SUCCESS);
458
459 case DDI_SUSPEND:
460 return (DDI_SUCCESS);
461
462 default:
463 return (DDI_FAILURE);
464
465 }
466 }
467
468 /* ARGSUSED */
469 static int
470 tsalarm_open(dev_t *devp, int flag, int otyp, cred_t *credp)
471 {
472 int rv, inst = getminor(*devp);
473 struct tsalarm_softc *softc;
474 glvc_xport_opt_op_t channel_op;
475 int rval;
476
477 softc = (struct tsalarm_softc *)getsoftc(inst);
478 if (softc == NULL) {
479 cmn_err(CE_WARN, "getsoftc failed\n");
480 return (EIO);
481 }
482
483 mutex_enter(&softc->mutex);
484
485 rv = ldi_ident_from_dev(*devp, &softc->li);
486 if (rv != 0) {
487 cmn_err(CE_WARN, "ldi_ident_from_dev failed\n");
488 goto FAIL;
489 }
490 softc->flags |= TSAL_IDENTED;
491
492 rv = ldi_open_by_name(ALARM_CHANNEL, FREAD | FWRITE, kcred, &softc->lh,
493 softc->li);
494 if (rv != 0) {
495 cmn_err(CE_WARN, "ldi_open_by_name failed\n");
496 goto FAIL;
497 }
498 softc->flags |= TSAL_OPENED;
499
500 /* Get the MTU of the target channel */
501 channel_op.op_sel = GLVC_XPORT_OPT_GET;
502 channel_op.opt_sel = GLVC_XPORT_OPT_MTU_SZ;
503 channel_op.opt_val = 0;
504
505 if ((rv = ldi_ioctl(softc->lh, GLVC_XPORT_IOCTL_OPT_OP,
506 (intptr_t)&channel_op, FKIOCTL, kcred, &rval)) < 0) {
507 cmn_err(CE_WARN, "ldi_ioctl failed\n");
508 goto FAIL;
509 }
510 softc->mtu_size = channel_op.opt_val;
511
512 if ((softc->req_ptr = (tsal_pcp_alarm_req_t *)kmem_zalloc(
513 sizeof (tsal_pcp_alarm_req_t),
514 KM_NOSLEEP)) == NULL) {
515 goto FAIL;
516 }
517 if ((softc->resp_ptr = (tsal_pcp_alarm_resp_t *)kmem_zalloc(
518 sizeof (tsal_pcp_alarm_resp_t),
519 KM_NOSLEEP)) == NULL) {
520 goto FAIL;
521 }
522 if ((softc->req_msg_hdr = (tsal_pcp_req_msg_hdr_t *)kmem_zalloc(
523 sizeof (tsal_pcp_req_msg_hdr_t),
524 KM_NOSLEEP)) == NULL) {
525 goto FAIL;
526 }
527 if ((softc->resp_msg_hdr = (tsal_pcp_resp_msg_hdr_t *)kmem_zalloc(
528 sizeof (tsal_pcp_resp_msg_hdr_t),
529 KM_NOSLEEP)) == NULL) {
530 goto FAIL;
531 }
532 if ((softc->peek_area = kmem_zalloc(softc->mtu_size,
533 KM_NOSLEEP)) == NULL) {
534 goto FAIL;
535 }
536 if ((softc->peek_read_area = kmem_zalloc(2*softc->mtu_size,
537 KM_NOSLEEP)) == NULL) {
538 goto FAIL;
539 }
540
541 rv = 0;
542
543 FAIL:
544 if (rv != 0) {
545 if (softc->flags & TSAL_OPENED)
546 (void) ldi_close(softc->lh, FREAD|FWRITE, credp);
547 if (softc->flags * TSAL_IDENTED)
548 (void) ldi_ident_release(softc->li);
549 softc->flags &= ~(TSAL_OPENED | TSAL_IDENTED);
550 if (softc->req_ptr != NULL)
551 kmem_free(softc->req_ptr,
552 sizeof (tsal_pcp_alarm_req_t));
553 if (softc->resp_ptr != NULL)
554 kmem_free(softc->resp_ptr,
555 sizeof (tsal_pcp_alarm_resp_t));
556 if (softc->req_msg_hdr != NULL)
557 kmem_free(softc->req_msg_hdr,
558 sizeof (tsal_pcp_req_msg_hdr_t));
559 if (softc->resp_msg_hdr != NULL)
560 kmem_free(softc->resp_msg_hdr,
561 sizeof (tsal_pcp_resp_msg_hdr_t));
562 if (softc->peek_area != NULL)
563 kmem_free(softc->peek_area, softc->mtu_size);
564 if (softc->peek_read_area != NULL)
565 kmem_free(softc->peek_read_area, 2*softc->mtu_size);
566 }
567 mutex_exit(&softc->mutex);
568
569 return (rv);
570 }
571
572
573 /* ARGSUSED */
574 static int
575 tsalarm_close(dev_t dev, int flag, int otyp, cred_t *credp)
576 {
577 int rv, inst = getminor(dev);
578 struct tsalarm_softc *softc;
579
580 softc = (struct tsalarm_softc *)getsoftc(inst);
581
582 if (softc == NULL) {
583 return (EIO);
584 }
585
586 mutex_enter(&softc->mutex);
587
588 rv = ldi_close(softc->lh, FREAD | FWRITE, kcred);
589 if (rv != 0) {
590 cmn_err(CE_WARN, "ldi_close failed \n");
591 }
592
593 ldi_ident_release(softc->li);
594 softc->flags &= ~(TSAL_OPENED | TSAL_IDENTED);
595
596 mutex_exit(&softc->mutex);
597
598 /*
599 * free global buffers
600 */
601 if (softc->read_area != NULL) {
602 kmem_free(softc->read_area, 2*softc->mtu_size);
603 softc->read_area = NULL;
604 }
605 if (softc->req_ptr != NULL) {
606 kmem_free(softc->req_ptr,
607 sizeof (tsal_pcp_alarm_req_t));
608 softc->req_ptr = NULL;
609 }
610 if (softc->resp_ptr != NULL) {
611 kmem_free(softc->resp_ptr,
612 sizeof (tsal_pcp_alarm_resp_t));
613 softc->resp_ptr = NULL;
614 }
615 if (softc->req_msg_hdr != NULL) {
616 kmem_free(softc->req_msg_hdr,
617 sizeof (tsal_pcp_req_msg_hdr_t));
618 softc->req_msg_hdr = NULL;
619 }
620 if (softc->resp_msg_hdr != NULL) {
621 kmem_free(softc->resp_msg_hdr,
622 sizeof (tsal_pcp_resp_msg_hdr_t));
623 softc->resp_msg_hdr = NULL;
624 }
625 if (softc->peek_area != NULL) {
626 kmem_free(softc->peek_area, softc->mtu_size);
627 softc->peek_area = NULL;
628 }
629 if (softc->peek_read_area != NULL) {
630 kmem_free(softc->peek_read_area, 2*softc->mtu_size);
631 softc->peek_read_area = NULL;
632 }
633
634 return (rv);
635 }
636
637
638 /* ARGSUSED */
639 static int
640 tsalarm_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
641 cred_t *credp, int *rvalp)
642 {
643 int inst = getminor(dev);
644 struct tsalarm_softc *softc;
645 int retval = 0;
646 ts_aldata_t ts_alinfo;
647 int alarm_type, alarm_state = 0;
648
649 if ((softc = getsoftc(inst)) == NULL)
650 return (ENXIO);
651
652 mutex_enter(&softc->mutex);
653
654 switch (cmd) {
655
656 case LOMIOCALSTATE:
657 case LOMIOCALSTATE_OLD:
658 {
659 if (ddi_copyin((caddr_t)arg, (caddr_t)&ts_alinfo,
660 sizeof (ts_aldata_t), mode) != 0) {
661 retval = EFAULT;
662 goto end;
663 }
664
665 alarm_type = ts_alinfo.alarm_no;
666 if ((alarm_type < ALARM_CRITICAL) ||
667 (alarm_type > ALARM_USER)) {
668 retval = EINVAL;
669 goto end;
670 }
671
672 retval = glvc_alarm_get(alarm_type, &alarm_state,
673 softc);
674
675 if (retval != 0)
676 goto end;
677
678 if ((alarm_state != 0) && (alarm_state != 1)) {
679 retval = EIO;
680 goto end;
681 }
682
683 ts_alinfo.alarm_state = alarm_state;
684 if (ddi_copyout((caddr_t)&ts_alinfo, (caddr_t)arg,
685 sizeof (ts_aldata_t), mode) != 0) {
686 retval = EFAULT;
687 goto end;
688 }
689 }
690 break;
691
692 case LOMIOCALCTL:
693 case LOMIOCALCTL_OLD:
694 {
695 if (ddi_copyin((caddr_t)arg, (caddr_t)&ts_alinfo,
696 sizeof (ts_aldata_t), mode) != 0) {
697 retval = EFAULT;
698 goto end;
699 }
700
701 alarm_type = ts_alinfo.alarm_no;
702 alarm_state = ts_alinfo.alarm_state;
703
704 if ((alarm_type < ALARM_CRITICAL) ||
705 (alarm_type > ALARM_USER)) {
706 retval = EINVAL;
707 goto end;
708 }
709 if ((alarm_state < ALARM_OFF) ||
710 (alarm_state > ALARM_ON)) {
711 retval = EINVAL;
712 goto end;
713 }
714
715 retval = glvc_alarm_set(alarm_type, alarm_state, softc);
716 }
717 break;
718
719 default:
720 retval = EINVAL;
721 break;
722 }
723
724 end:
725 mutex_exit(&softc->mutex);
726
727 return (retval);
728 }
729
730 static int
731 glvc_alarm_get(int alarm_type, int *alarm_state, tsalarm_softc_t *sc)
732 {
733 tsal_pcp_alarm_req_t *req_ptr = NULL;
734 tsal_pcp_alarm_resp_t *resp_ptr = NULL;
735 tsal_pcp_msg_t send_msg;
736 tsal_pcp_msg_t recv_msg;
737 int status = -1;
738
739 /*
740 * setup the request data to attach to the libpcp msg
741 */
742 if (sc->req_ptr == NULL) {
743 goto alarm_return;
744 }
745
746 req_ptr = sc->req_ptr;
747
748 req_ptr->alarm_action = PCP_ALARM_STATUS;
749 req_ptr->alarm_id = alarm_type;
750
751 send_msg.msg_type = PCP_ALARM_CONTROL;
752 send_msg.sub_type = NULL;
753 send_msg.msg_len = sizeof (tsal_pcp_alarm_req_t);
754 send_msg.msg_data = (uint8_t *)req_ptr;
755
756 /*
757 * send the request, receive the response
758 */
759 if (tsal_pcp_send_recv(sc, &send_msg, &recv_msg,
760 PCP_COMM_TIMEOUT) < 0) {
761 /* we either timed out or erred; either way try again */
762 (void) ddi_sleep(PCP_COMM_TIMEOUT);
763
764 if (tsal_pcp_send_recv(sc, &send_msg, &recv_msg,
765 PCP_COMM_TIMEOUT) < 0) {
766 cmn_err(CE_WARN, "tsalarm: communication failure");
767 goto alarm_return;
768 }
769 }
770
771 /*
772 * validate that this data was meant for us
773 */
774 if (recv_msg.msg_type != PCP_ALARM_CONTROL_R) {
775 cmn_err(CE_WARN, "tsalarm: unbound packet received");
776 goto alarm_return;
777 }
778
779 /*
780 * verify that the Alarm action has taken place
781 */
782 resp_ptr = (tsal_pcp_alarm_resp_t *)recv_msg.msg_data;
783 if (resp_ptr->status == PCP_ALARM_ERROR) {
784 cmn_err(CE_WARN, "tsalarm: failed to get alarm status");
785 goto alarm_return;
786 }
787
788 if (resp_ptr->alarm_state == ALARM_STATE_UNKNOWN)
789 cmn_err(CE_WARN, "tsalarm: ALARM set to unknown state");
790
791 *alarm_state = resp_ptr->alarm_state;
792 status = TSAL_PCP_OK;
793
794 alarm_return:
795 return (status);
796 }
797
798 static int
799 glvc_alarm_set(int alarm_type, int new_state, tsalarm_softc_t *sc)
800 {
801 tsal_pcp_alarm_req_t *req_ptr = NULL;
802 tsal_pcp_alarm_resp_t *resp_ptr = NULL;
803 tsal_pcp_msg_t send_msg;
804 tsal_pcp_msg_t recv_msg;
805 int status = -1;
806
807 /*
808 * setup the request data to attach to the libpcp msg
809 */
810 if (sc->req_ptr == NULL) {
811 if ((sc->req_ptr = (tsal_pcp_alarm_req_t *)kmem_zalloc(
812 sizeof (tsal_pcp_alarm_req_t),
813 KM_NOSLEEP)) == NULL)
814 goto alarm_return;
815 }
816
817 req_ptr = sc->req_ptr;
818
819 if (new_state == ALARM_ON)
820 req_ptr->alarm_action = PCP_ALARM_ENABLE;
821 else if (new_state == ALARM_OFF)
822 req_ptr->alarm_action = PCP_ALARM_DISABLE;
823
824 req_ptr->alarm_id = alarm_type;
825
826 send_msg.msg_type = PCP_ALARM_CONTROL;
827 send_msg.sub_type = NULL;
828 send_msg.msg_len = sizeof (tsal_pcp_alarm_req_t);
829 send_msg.msg_data = (uint8_t *)req_ptr;
830
831 /*
832 * send the request, receive the response
833 */
834 if (tsal_pcp_send_recv(sc, &send_msg, &recv_msg,
835 PCP_COMM_TIMEOUT) < 0) {
836 /* we either timed out or erred; either way try again */
837 (void) ddi_sleep(PCP_COMM_TIMEOUT);
838
839 if (tsal_pcp_send_recv(sc, &send_msg, &recv_msg,
840 PCP_COMM_TIMEOUT) < 0) {
841 goto alarm_return;
842 }
843 }
844
845 /*
846 * validate that this data was meant for us
847 */
848 if (recv_msg.msg_type != PCP_ALARM_CONTROL_R) {
849 cmn_err(CE_WARN, "tsalarm: unbound packet received");
850 goto alarm_return;
851 }
852
853 /*
854 * verify that the Alarm action has taken place
855 */
856 resp_ptr = (tsal_pcp_alarm_resp_t *)recv_msg.msg_data;
857 if (resp_ptr->status == PCP_ALARM_ERROR) {
858 cmn_err(CE_WARN, "tsalarm: failed to set alarm status");
859 goto alarm_return;
860 }
861
862 /*
863 * ensure the Alarm action taken is the one requested
864 */
865 if ((req_ptr->alarm_action == PCP_ALARM_DISABLE) &&
866 (resp_ptr->alarm_state != ALARM_STATE_OFF)) {
867 cmn_err(CE_WARN, "tsalarm: failed to set alarm");
868 goto alarm_return;
869 } else if ((req_ptr->alarm_action == PCP_ALARM_ENABLE) &&
870 (resp_ptr->alarm_state != ALARM_STATE_ON)) {
871 cmn_err(CE_WARN, "tsalarm: failed to set alarm");
872 goto alarm_return;
873 } else if (resp_ptr->alarm_state == ALARM_STATE_UNKNOWN) {
874 cmn_err(CE_WARN, "tsalarm: Alarm set to unknown state");
875 goto alarm_return;
876 }
877
878 status = TSAL_PCP_OK;
879
880 alarm_return:
881 return (status);
882 }
883 /*
884 * Function: Send and Receive messages on platform channel.
885 * Arguments:
886 * int channel_fd - channel file descriptor.
887 * tsal_pcp_msg_t *req_msg - Request Message to send to other end of channel.
888 * tsal_pcp_msg_t *resp_msg - Response Message to be received.
889 * uint32_t timeout - timeout field when waiting for data from channel.
890 * Returns:
891 * 0 - success (TSAL_PCP_OK).
892 * (-1) - failure (TSAL_PCP_ERROR).
893 */
894 static int
895 tsal_pcp_send_recv(tsalarm_softc_t *sc, tsal_pcp_msg_t *req_msg,
896 tsal_pcp_msg_t *resp_msg, uint32_t timeout)
897 {
898 void *datap;
899 void *resp_msg_data = NULL;
900 uint32_t status;
901 uint16_t cksum = 0;
902 int ret;
903 int resp_hdr_ok;
904 tsal_pcp_req_msg_hdr_t *req_msg_hdr = NULL;
905 tsal_pcp_resp_msg_hdr_t *resp_msg_hdr = NULL;
906 #ifdef PCP_CKSUM_ENABLE
907 uint16_t bkup_resp_hdr_cksum;
908 #endif
909
910
911 if (req_msg == NULL) {
912 return (TSAL_PCP_ERROR);
913 }
914
915 if ((req_msg->msg_len != 0) && ((datap = req_msg->msg_data) == NULL))
916 return (TSAL_PCP_ERROR);
917
918 req_msg_hdr = sc->req_msg_hdr;
919
920 if (req_msg_hdr == NULL)
921 return (TSAL_PCP_ERROR);
922
923 if (req_msg->msg_len != 0) {
924 /* calculate request msg_cksum */
925 cksum = checksum((uint16_t *)datap, req_msg->msg_len);
926 }
927
928 /*
929 * Fill in the message header for the request packet
930 */
931 req_msg_hdr->magic_num = PCP_MAGIC_NUM;
932 req_msg_hdr->proto_ver = PCP_PROT_VER_1;
933 req_msg_hdr->msg_type = req_msg->msg_type;
934 req_msg_hdr->sub_type = req_msg->sub_type;
935 req_msg_hdr->rsvd_pad = 0;
936 req_msg_hdr->xid = tsal_pcp_get_xid(sc);
937 req_msg_hdr->msg_len = req_msg->msg_len;
938 req_msg_hdr->timeout = timeout;
939 req_msg_hdr->msg_cksum = cksum;
940 req_msg_hdr->hdr_cksum = 0;
941
942 /* fill request header checksum */
943 req_msg_hdr->hdr_cksum = checksum((uint16_t *)req_msg_hdr,
944 sizeof (tsal_pcp_req_msg_hdr_t));
945
946 /*
947 * send request message header
948 */
949 if ((ret = tsal_pcp_send_req_msg_hdr(sc, req_msg_hdr))) {
950 return (ret);
951 }
952
953 /*
954 * send request message
955 */
956 if (req_msg->msg_len != 0) {
957 if ((ret = tsal_pcp_io_op(sc, datap, req_msg->msg_len,
958 PCP_IO_OP_WRITE))) {
959 return (ret);
960 }
961 }
962
963 if (timeout == (uint32_t)PCP_TO_NO_RESPONSE)
964 return (TSAL_PCP_OK);
965
966 resp_msg_hdr = sc->resp_msg_hdr;
967
968 if (resp_msg_hdr == NULL) {
969 return (TSAL_PCP_ERROR);
970 }
971
972 resp_hdr_ok = 0;
973 while (!resp_hdr_ok) {
974 /*
975 * Receive response message header
976 * Note: frame error handling is done in
977 * 'tsal_pcp_recv_resp_msg_hdr()'.
978 */
979 if ((ret = tsal_pcp_recv_resp_msg_hdr(sc, resp_msg_hdr))) {
980 return (ret);
981 }
982
983 /*
984 * Check header checksum if it matches with the received hdr
985 * checksum.
986 */
987 #ifdef PCP_CKSUM_ENABLE
988 bkup_resp_hdr_cksum = resp_msg_hdr->hdr_cksum;
989 resp_msg_hdr->hdr_cksum = 0;
990 cksum = checksum((uint16_t *)resp_msg_hdr,
991 sizeof (tsal_pcp_resp_msg_hdr_t));
992
993 if (cksum != bkup_resp_hdr_cksum) {
994 return (TSAL_PCP_ERROR);
995 }
996 #endif
997 /*
998 * Check for matching request and response messages
999 */
1000 if (resp_msg_hdr->xid != req_msg_hdr->xid) {
1001 continue; /* continue reading response header */
1002 }
1003 resp_hdr_ok = 1;
1004 }
1005
1006 /*
1007 * check status field for any channel protocol errrors
1008 * This field signifies something happend during request
1009 * message trasmission. This field is set by the receiver.
1010 */
1011 status = resp_msg_hdr->status;
1012 if (status != TSAL_PCP_OK) {
1013 return (TSAL_PCP_ERROR);
1014 }
1015
1016 if (resp_msg_hdr->msg_len != 0) {
1017 if (sc->resp_ptr == NULL)
1018 return (TSAL_PCP_ERROR);
1019
1020 resp_msg_data = (uint8_t *)sc->resp_ptr;
1021 /*
1022 * Receive response message.
1023 */
1024 if ((ret = tsal_pcp_io_op(sc, resp_msg_data,
1025 resp_msg_hdr->msg_len,
1026 PCP_IO_OP_READ))) {
1027 return (ret);
1028 }
1029
1030 #ifdef PCP_CKSUM_ENABLE
1031 /* verify response message data checksum */
1032 cksum = checksum((uint16_t *)resp_msg_data,
1033 resp_msg_hdr->msg_len);
1034 if (cksum != resp_msg_hdr->msg_cksum) {
1035 return (TSAL_PCP_ERROR);
1036 }
1037 #endif
1038 }
1039 /* Everything is okay put the received data into user */
1040 /* resp_msg struct */
1041 resp_msg->msg_len = resp_msg_hdr->msg_len;
1042 resp_msg->msg_type = resp_msg_hdr->msg_type;
1043 resp_msg->sub_type = resp_msg_hdr->sub_type;
1044 resp_msg->msg_data = (uint8_t *)resp_msg_data;
1045
1046 return (TSAL_PCP_OK);
1047 }
1048
1049 /*
1050 * Function: wrapper for handling glvc calls (read/write/peek).
1051 */
1052 static int
1053 tsal_pcp_io_op(tsalarm_softc_t *sc, void *buf, int byte_cnt, int io_op)
1054 {
1055 int rv;
1056 int n;
1057 uint8_t *datap;
1058 int (*func_ptr)(tsalarm_softc_t *, uint8_t *, int);
1059 int io_sz;
1060 int try_cnt;
1061
1062 if ((buf == NULL) || (byte_cnt < 0)) {
1063 return (TSAL_PCP_ERROR);
1064 }
1065
1066 switch (io_op) {
1067 case PCP_IO_OP_READ:
1068 func_ptr = tsal_pcp_read;
1069 break;
1070 case PCP_IO_OP_WRITE:
1071 func_ptr = tsal_pcp_write;
1072 break;
1073 case PCP_IO_OP_PEEK:
1074 func_ptr = tsal_pcp_peek;
1075 break;
1076 default:
1077 return (TSAL_PCP_ERROR);
1078 }
1079
1080 /*
1081 * loop until all I/O done, try limit exceded, or real failure
1082 */
1083
1084 rv = 0;
1085 datap = buf;
1086 while (rv < byte_cnt) {
1087 io_sz = MIN((byte_cnt - rv), sc->mtu_size);
1088 try_cnt = 0;
1089 while ((n = (*func_ptr)(sc, datap, io_sz)) < 0) {
1090 try_cnt++;
1091 if (try_cnt > PCP_MAX_TRY_CNT) {
1092 rv = n;
1093 goto done;
1094 }
1095 /* waiting 5 secs. Do we need 5 Secs? */
1096 (void) ddi_sleep(PCP_GLVC_SLEEP);
1097 } /* while trying the io operation */
1098
1099 if (n < 0) {
1100 rv = n;
1101 goto done;
1102 }
1103 rv += n;
1104 datap += n;
1105 } /* while still have more data */
1106
1107 done:
1108 if (rv == byte_cnt)
1109 return (0);
1110 else
1111 return (TSAL_PCP_ERROR);
1112 }
1113
1114 /*
1115 * For peeking 'bytes_cnt' bytes in channel (glvc) buffers.
1116 * If data is available, the data is copied into 'buf'.
1117 */
1118 static int
1119 tsal_pcp_peek(tsalarm_softc_t *sc, uint8_t *buf, int bytes_cnt)
1120 {
1121 int ret, rval;
1122 glvc_xport_msg_peek_t peek_ctrl;
1123 int n, m;
1124
1125 if (bytes_cnt < 0 || bytes_cnt > sc->mtu_size) {
1126 return (TSAL_PCP_ERROR);
1127 }
1128
1129 /*
1130 * initialization of buffers used for peeking data in channel buffers.
1131 */
1132 if (sc->peek_area == NULL) {
1133 return (TSAL_PCP_ERROR);
1134 }
1135
1136 /*
1137 * peek max MTU size bytes
1138 */
1139 peek_ctrl.buf = (caddr_t)sc->peek_area;
1140 peek_ctrl.buflen = sc->mtu_size;
1141 peek_ctrl.flags = 0;
1142
1143 if ((ret = ldi_ioctl(sc->lh, GLVC_XPORT_IOCTL_DATA_PEEK,
1144 (intptr_t)&peek_ctrl, FKIOCTL, kcred, &rval)) < 0) {
1145 return (ret);
1146 }
1147
1148 n = peek_ctrl.buflen;
1149
1150 if (n < 0)
1151 return (TSAL_PCP_ERROR);
1152
1153 /*
1154 * satisfy request as best as we can
1155 */
1156 m = MIN(bytes_cnt, n);
1157 (void) memcpy(buf, sc->peek_area, m);
1158
1159 return (m);
1160 }
1161
1162 /*
1163 * Function: write 'byte_cnt' bytes from 'buf' to channel.
1164 */
1165 static int
1166 tsal_pcp_write(tsalarm_softc_t *sc, uint8_t *buf, int byte_cnt)
1167 {
1168 int ret;
1169 struct uio uio;
1170 struct iovec iov;
1171
1172 /* check for valid arguments */
1173 if (buf == NULL || byte_cnt < 0 || byte_cnt > sc->mtu_size) {
1174 return (TSAL_PCP_ERROR);
1175 }
1176 bzero(&uio, sizeof (uio));
1177 bzero(&iov, sizeof (iov));
1178 iov.iov_base = (int8_t *)buf;
1179 iov.iov_len = byte_cnt;
1180 uio.uio_iov = &iov;
1181 uio.uio_iovcnt = 1;
1182 uio.uio_loffset = 0;
1183 uio.uio_segflg = UIO_SYSSPACE;
1184 uio.uio_resid = byte_cnt;
1185
1186 if ((ret = ldi_write(sc->lh, &uio, kcred)) < 0) {
1187 return (ret);
1188 }
1189 return (byte_cnt - iov.iov_len);
1190 }
1191
1192 /*
1193 * In current implementaion of glvc driver, streams reads are not supported.
1194 * tsal_pcp_read mimics stream reads by first reading all the bytes present in
1195 * channel buffer into a local buffer and from then on read requests
1196 * are serviced from local buffer. When read requests are not serviceble
1197 * from local buffer, it repeates by first reading data from channel buffers.
1198 */
1199
1200 static int
1201 tsal_pcp_read(tsalarm_softc_t *sc, uint8_t *buf, int byte_cnt)
1202 {
1203 int ret;
1204 int n, m, i;
1205 struct uio uio;
1206 struct iovec iov;
1207 int read_area_size = 0;
1208
1209 if (byte_cnt < 0 || byte_cnt > sc->mtu_size) {
1210 return (TSAL_PCP_ERROR);
1211 }
1212
1213 read_area_size = 2*sc->mtu_size;
1214 /*
1215 * initialization of local read buffer
1216 * from which the stream read requests are serviced.
1217 */
1218 if (sc->read_area == NULL) {
1219 sc->read_area = kmem_zalloc(read_area_size,
1220 KM_NOSLEEP);
1221 if (sc->read_area == NULL) {
1222 return (TSAL_PCP_ERROR);
1223 }
1224 sc->read_head = sc->read_area;
1225 sc->read_tail = sc->read_area;
1226 }
1227
1228 /*
1229 * if we already read this data then copy from local buffer it self
1230 * without calling new read.
1231 */
1232 if (byte_cnt <= (sc->read_tail - sc->read_head)) {
1233 (void) memcpy(buf, sc->read_head, byte_cnt);
1234 sc->read_head += byte_cnt;
1235 return (byte_cnt);
1236 }
1237
1238 /*
1239 * if the request is not satisfied from the buffered data, then move
1240 * remaining data to front of the buffer and read new data.
1241 */
1242 for (i = 0; i < (sc->read_tail - sc->read_head); ++i) {
1243 sc->read_area[i] = sc->read_head[i];
1244 }
1245 sc->read_head = sc->read_area;
1246 sc->read_tail = sc->read_head + i;
1247
1248 /*
1249 * do a peek to see how much data is available and read complete data.
1250 */
1251
1252 if ((m = tsal_pcp_peek(sc, sc->read_tail, sc->mtu_size)) < 0) {
1253 return (m);
1254 }
1255
1256 bzero(&uio, sizeof (uio));
1257 bzero(&iov, sizeof (iov));
1258 iov.iov_base = (int8_t *)sc->read_tail;
1259 iov.iov_len = m;
1260 uio.uio_iov = &iov;
1261 uio.uio_iovcnt = 1;
1262 uio.uio_loffset = 0;
1263 uio.uio_segflg = UIO_SYSSPACE;
1264 uio.uio_resid = m;
1265
1266 if ((ret = ldi_read(sc->lh, &uio, kcred)) != 0) {
1267 return (ret);
1268 }
1269
1270 sc->read_tail += (m - iov.iov_len);
1271
1272 /*
1273 * copy the requested bytes.
1274 */
1275 n = MIN(byte_cnt, (sc->read_tail - sc->read_head));
1276 (void) memcpy(buf, sc->read_head, n);
1277
1278 sc->read_head += n;
1279
1280 return (n);
1281 }
1282 /*
1283 * This function is slight different from tsal_pcp_peek. The peek requests are
1284 * serviced from local read buffer, if data is available. If the peek request
1285 * is not serviceble from local read buffer, then the data is peeked from
1286 * channel buffer. This function is mainly used for proper protocol framing
1287 * error handling.
1288 */
1289 static int
1290 tsal_pcp_peek_read(tsalarm_softc_t *sc, uint8_t *buf, int byte_cnt)
1291 {
1292 int n, m, i;
1293 uint8_t *peek_read_head = NULL;
1294 uint8_t *peek_read_tail = NULL;
1295
1296 if (byte_cnt < 0 || byte_cnt > sc->mtu_size) {
1297 return (TSAL_PCP_ERROR);
1298 }
1299
1300 /*
1301 * if we already have the data in local read buffer then copy
1302 * from local buffer it self w/out calling new peek
1303 */
1304 if (byte_cnt <= (sc->read_tail - sc->read_head)) {
1305 (void) memcpy(buf, sc->read_head, byte_cnt);
1306 return (byte_cnt);
1307 }
1308
1309
1310 if (sc->peek_read_area == NULL) {
1311 return (TSAL_PCP_ERROR);
1312 }
1313 peek_read_head = sc->peek_read_area;
1314 peek_read_tail = sc->peek_read_area;
1315
1316 /*
1317 * if the request is not satisfied from local read buffer, then first
1318 * copy the remaining data in local read buffer to peek_read_area and
1319 * then issue new peek.
1320 */
1321 for (i = 0; i < (sc->read_tail - sc->read_head); ++i) {
1322 sc->peek_read_area[i] = sc->read_head[i];
1323 }
1324 peek_read_head = sc->peek_read_area;
1325 peek_read_tail = peek_read_head + i;
1326
1327 /*
1328 * do a peek to see how much data is available and read complete data.
1329 */
1330
1331 if ((m = tsal_pcp_peek(sc, peek_read_tail, sc->mtu_size)) < 0) {
1332 return (m);
1333 }
1334
1335 peek_read_tail += m;
1336
1337 /*
1338 * copy the requested bytes
1339 */
1340 n = MIN(byte_cnt, (peek_read_tail - peek_read_head));
1341 (void) memcpy(buf, peek_read_head, n);
1342
1343 return (n);
1344 }
1345 /*
1346 * Send Request Message Header.
1347 */
1348 static int
1349 tsal_pcp_send_req_msg_hdr(tsalarm_softc_t *sc, tsal_pcp_req_msg_hdr_t *req_hdr)
1350 {
1351 tsal_pcp_req_msg_hdr_t *hdrp;
1352 int hdr_sz;
1353 int ret;
1354
1355 hdr_sz = sizeof (tsal_pcp_req_msg_hdr_t);
1356 if ((hdrp = (tsal_pcp_req_msg_hdr_t *)kmem_zalloc(hdr_sz,
1357 KM_NOSLEEP)) == NULL) {
1358 return (TSAL_PCP_ERROR);
1359 }
1360
1361 hdrp->magic_num = htonl(req_hdr->magic_num);
1362 hdrp->proto_ver = req_hdr->proto_ver;
1363 hdrp->msg_type = req_hdr->msg_type;
1364 hdrp->sub_type = req_hdr->sub_type;
1365 hdrp->rsvd_pad = htons(req_hdr->rsvd_pad);
1366 hdrp->xid = htonl(req_hdr->xid);
1367 hdrp->timeout = htonl(req_hdr->timeout);
1368 hdrp->msg_len = htonl(req_hdr->msg_len);
1369 hdrp->msg_cksum = htons(req_hdr->msg_cksum);
1370 hdrp->hdr_cksum = htons(req_hdr->hdr_cksum);
1371
1372 if ((ret = tsal_pcp_io_op(sc, (char *)hdrp, hdr_sz,
1373 PCP_IO_OP_WRITE)) != 0) {
1374 kmem_free(hdrp, hdr_sz);
1375 return (ret);
1376 }
1377 kmem_free(hdrp, hdr_sz);
1378 return (TSAL_PCP_OK);
1379 }
1380 /*
1381 * Receive Response message header.
1382 */
1383 static int
1384 tsal_pcp_recv_resp_msg_hdr(tsalarm_softc_t *sc,
1385 tsal_pcp_resp_msg_hdr_t *resp_hdr)
1386 {
1387 uint32_t magic_num;
1388 uint8_t proto_ver;
1389 uint8_t msg_type;
1390 uint8_t sub_type;
1391 uint8_t rsvd_pad;
1392 uint32_t xid;
1393 uint32_t timeout;
1394 uint32_t msg_len;
1395 uint32_t status;
1396 uint16_t msg_cksum;
1397 uint16_t hdr_cksum;
1398 int ret;
1399
1400 if (resp_hdr == NULL) {
1401 return (TSAL_PCP_ERROR);
1402 }
1403
1404 /*
1405 * handle protocol framing errors.
1406 * tsal_pcp_frame_error_handle() returns when proper frame arrived
1407 * (magic seq) or if an error happens while reading data from
1408 * channel.
1409 */
1410 if ((ret = tsal_pcp_frame_error_handle(sc)) != 0) {
1411 return (TSAL_PCP_ERROR);
1412 }
1413
1414 /* read magic number first */
1415 if ((ret = tsal_pcp_io_op(sc, &magic_num, sizeof (magic_num),
1416 PCP_IO_OP_READ)) != 0) {
1417 return (ret);
1418 }
1419
1420 magic_num = ntohl(magic_num);
1421
1422 if (magic_num != PCP_MAGIC_NUM) {
1423 return (TSAL_PCP_ERROR);
1424 }
1425
1426 /* read version field */
1427 if ((ret = tsal_pcp_io_op(sc, &proto_ver, sizeof (proto_ver),
1428 PCP_IO_OP_READ)) != 0) {
1429 return (ret);
1430 }
1431
1432 /* check protocol version */
1433 if (proto_ver != PCP_PROT_VER_1) {
1434 return (TSAL_PCP_ERROR);
1435 }
1436
1437 /* Read message type */
1438 if ((ret = tsal_pcp_io_op(sc, &msg_type, sizeof (msg_type),
1439 PCP_IO_OP_READ)) != 0) {
1440 return (ret);
1441 }
1442
1443 /* Read message sub type */
1444 if ((ret = tsal_pcp_io_op(sc, &sub_type, sizeof (sub_type),
1445 PCP_IO_OP_READ)) != 0) {
1446 return (ret);
1447 }
1448
1449 /* Read rcvd_pad bits */
1450 if ((ret = tsal_pcp_io_op(sc, &rsvd_pad, sizeof (rsvd_pad),
1451 PCP_IO_OP_READ)) != 0) {
1452 return (ret);
1453 }
1454
1455 /* receive transaction id */
1456 if ((ret = tsal_pcp_io_op(sc, &xid, sizeof (xid),
1457 PCP_IO_OP_READ)) != 0) {
1458 return (ret);
1459 }
1460
1461 xid = ntohl(xid);
1462
1463 /* receive timeout value */
1464 if ((ret = tsal_pcp_io_op(sc, &timeout, sizeof (timeout),
1465 PCP_IO_OP_READ)) != 0) {
1466 return (ret);
1467 }
1468
1469 timeout = ntohl(timeout);
1470
1471 /* receive message length */
1472 if ((ret = tsal_pcp_io_op(sc, &msg_len, sizeof (msg_len),
1473 PCP_IO_OP_READ)) != 0) {
1474 return (ret);
1475 }
1476
1477 msg_len = ntohl(msg_len);
1478
1479 /* receive status field */
1480 if ((ret = tsal_pcp_io_op(sc, &status, sizeof (status),
1481 PCP_IO_OP_READ)) != 0) {
1482 return (ret);
1483 }
1484
1485 status = ntohl(status);
1486
1487 /* receive message checksum */
1488 if ((ret = tsal_pcp_io_op(sc, &msg_cksum, sizeof (msg_cksum),
1489 PCP_IO_OP_READ)) != 0) {
1490 return (ret);
1491 }
1492
1493 msg_cksum = ntohs(msg_cksum);
1494
1495 /* receive header checksum */
1496 if ((ret = tsal_pcp_io_op(sc, &hdr_cksum, sizeof (hdr_cksum),
1497 PCP_IO_OP_READ)) != 0) {
1498 return (ret);
1499 }
1500
1501 hdr_cksum = ntohs(hdr_cksum);
1502
1503 /* copy to resp_hdr */
1504
1505 resp_hdr->magic_num = magic_num;
1506 resp_hdr->proto_ver = proto_ver;
1507 resp_hdr->msg_type = msg_type;
1508 resp_hdr->sub_type = sub_type;
1509 resp_hdr->rsvd_pad = rsvd_pad;
1510 resp_hdr->xid = xid;
1511 resp_hdr->timeout = timeout;
1512 resp_hdr->msg_len = msg_len;
1513 resp_hdr->status = status;
1514 resp_hdr->msg_cksum = msg_cksum;
1515 resp_hdr->hdr_cksum = hdr_cksum;
1516
1517 return (TSAL_PCP_OK);
1518 }
1519
1520 /*
1521 * Get next xid for including in request message.
1522 * Every request and response message are matched
1523 * for same xid.
1524 */
1525
1526 static uint32_t
1527 tsal_pcp_get_xid(tsalarm_softc_t *sc)
1528 {
1529 uint32_t ret;
1530 static boolean_t xid_initialized = B_FALSE;
1531
1532 if (xid_initialized == B_FALSE) {
1533 xid_initialized = B_TRUE;
1534 /*
1535 * starting xid is initialized to a different value everytime
1536 * user application is restarted so that user apps will not
1537 * receive previous session's packets.
1538 *
1539 * Note: The algorithm for generating initial xid is partially
1540 * taken from Solaris rpc code.
1541 */
1542 sc->msg_xid = (uint32_t)gethrtime();
1543 }
1544
1545 ret = sc->msg_xid++;
1546
1547 /* zero xid is not allowed */
1548 if (ret == 0)
1549 ret = sc->msg_xid++;
1550
1551 return (ret);
1552 }
1553
1554 /*
1555 * This function handles channel framing errors. It waits until proper
1556 * frame with starting sequence as magic numder (0xAFBCAFA0)
1557 * is arrived. It removes unexpected data (before the magic number sequence)
1558 * on the channel. It returns when proper magic number sequence is seen
1559 * or when any failure happens while reading/peeking the channel.
1560 */
1561 static int
1562 tsal_pcp_frame_error_handle(tsalarm_softc_t *sc)
1563 {
1564 uint8_t magic_num_buf[4];
1565 int ispresent = 0;
1566 uint32_t net_magic_num; /* magic byte in network byte order */
1567 uint32_t host_magic_num = PCP_MAGIC_NUM;
1568 uint8_t buf[2];
1569
1570 net_magic_num = htonl(host_magic_num);
1571 (void) memcpy(magic_num_buf, (uint8_t *)&net_magic_num, 4);
1572
1573 while (!ispresent) {
1574 /*
1575 * Check if next four bytes matches pcp magic number.
1576 * if mathing not found, discard 1 byte and continue checking.
1577 */
1578 if (!check_magic_byte_presence(sc, 4, &magic_num_buf[0],
1579 &ispresent)) {
1580 if (!ispresent) {
1581 /* remove 1 byte */
1582 (void) tsal_pcp_io_op(sc, buf, 1,
1583 PCP_IO_OP_READ);
1584 }
1585 } else {
1586 return (-1);
1587 }
1588 }
1589
1590 return (0);
1591 }
1592
1593 /*
1594 * checks whether certain byte sequence is present in the data stream.
1595 */
1596 static int
1597 check_magic_byte_presence(tsalarm_softc_t *sc,
1598 int byte_cnt, uint8_t *byte_seq, int *ispresent)
1599 {
1600 int ret, i;
1601 uint8_t buf[4];
1602
1603 if ((ret = tsal_pcp_peek_read(sc, buf, byte_cnt)) < 0) {
1604 return (ret);
1605 }
1606
1607 /* 'byte_cnt' bytes not present */
1608 if (ret != byte_cnt) {
1609 *ispresent = 0;
1610 return (0);
1611 }
1612
1613 for (i = 0; i < byte_cnt; ++i) {
1614 if (buf[i] != byte_seq[i]) {
1615 *ispresent = 0;
1616 return (0);
1617 }
1618 }
1619 *ispresent = 1;
1620
1621 return (0);
1622 }
1623
1624 /*
1625 * 16-bit simple internet checksum
1626 */
1627 static uint16_t
1628 checksum(uint16_t *addr, int32_t count)
1629 {
1630 /*
1631 * Compute Internet Checksum for "count" bytes
1632 * beginning at location "addr".
1633 */
1634
1635 register uint32_t sum = 0;
1636
1637 while (count > 1) {
1638 /* This is the inner loop */
1639 sum += *(unsigned short *)addr++;
1640 count -= 2;
1641 }
1642
1643 /* Add left-over byte, if any */
1644 if (count > 0)
1645 sum += * (unsigned char *)addr;
1646
1647 /* Fold 32-bit sum to 16 bits */
1648 while (sum >> 16)
1649 sum = (sum & 0xffff) + (sum >> 16);
1650
1651 sum = (~sum) & 0xffff;
1652 if (sum == 0)
1653 sum = 0xffff;
1654
1655 return (sum);
1656 }
Unleashed OS