The OpenHPI Project

The left column is the number of times the code was executed during the unit test suites.

Exec		Code	Line #
		Source:safhpi.c	1
		Graph:.libs/safhpi.gcno	2
		Data:.libs/safhpi.gcda	3
		Runs:378	4
		Programs:378	5
		/* -*- linux-c -*-	6
		*	7
		* Copyright (c) 2003 by Intel Corp.	8
		* (C) Copyright IBM Corp. 2003-2004	9
		* Copyright (c) 2004 by FORCE Computers.	10
		*	11
		* This program is distributed in the hope that it will be useful,	12
		* but WITHOUT ANY WARRANTY; without even the implied warranty of	13
		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. This	14
		* file and program are licensed under a BSD style license. See	15
		* the Copying file included with the OpenHPI distribution for	16
		* full licensing terms.	17
		*	18
		* Authors:	19
		* Louis Zhuang < address removed >	20
		* Sean Dague < address removed >	21
		* Rusty Lynch	22
		* David Judkovics < address removed >	23
		* Thomas Kanngieser < address removed >	24
		* Renier Morales < address removed >	25
		* Racing Guo < address removed >	26
		*/	27
			28
		#include <string.h>	29
		#include <SaHpi.h>	30
		#include <openhpi.h>	31
		#include <sahpimacros.h>	32
			33
		/*********************************************************************	34
		*	35
		* Begin SAHPI B.1.1 Functions. For full documentation please see	36
		* the specification	37
		*	38
		********************************************************************/	39
			40
		SaHpiVersionT SAHPI_API saHpiVersionGet ()	41
1		{	42
1		return SAHPI_INTERFACE_VERSION;	43
		}	44
			45
		SaErrorT SAHPI_API saHpiSessionOpen(	46
		SAHPI_IN SaHpiDomainIdT DomainId,	47
		SAHPI_OUT SaHpiSessionIdT *SessionId,	48
		SAHPI_IN void *SecurityParams)	49
376		{	50
376		SaHpiSessionIdT sid;	51
376		SaHpiDomainIdT did;	52
			53
376		if (SessionId == NULL) {	54
1		dbg("Invalid Session Id pointer");	55
1		return SA_ERR_HPI_INVALID_PARAMS;	56
		}	57
			58
		/* Security Params required to be NULL by the spec at this point */	59
375		if (SecurityParams != NULL) {	60
1		dbg("SecurityParams must be NULL");	61
1		return SA_ERR_HPI_INVALID_PARAMS;	62
		}	63
			64
374		if (oh_initialized() != SA_OK && oh_initialize() != SA_OK) {	65
0		dbg("ERROR. Could not initialize the library");	66
0		return SA_ERR_HPI_INTERNAL_ERROR;	67
		}	68
			69
374		if (DomainId == SAHPI_UNSPECIFIED_DOMAIN_ID)	70
373		did = oh_get_default_domain_id();	71
		else	72
1		did = DomainId;	73
			74
374		sid = oh_create_session(did);	75
374		if(!sid) {	76
1		dbg("Domain %d does not exist or unable to create session!", did);	77
1		return SA_ERR_HPI_INVALID_DOMAIN;	78
		}	79
			80
373		*SessionId = sid;	81
			82
373		return SA_OK;	83
		}	84
			85
		SaErrorT SAHPI_API saHpiSessionClose(	86
		SAHPI_IN SaHpiSessionIdT SessionId)	87
364		{	88
364		OH_CHECK_INIT_STATE(SessionId);	89
			90
362		return oh_destroy_session(SessionId);	91
		}	92
			93
		SaErrorT SAHPI_API saHpiDiscover(	94
		SAHPI_IN SaHpiSessionIdT SessionId)	95
371		{	96
371		SaHpiDomainIdT did;	97
371		int rv = SA_ERR_HPI_ERROR;	98
371		unsigned int hid = 0, next_hid;	99
371		struct oh_handler *h = NULL;	100
			101
371		OH_CHECK_INIT_STATE(SessionId);	102
369		OH_GET_DID(SessionId, did);	103
			104
369		data_access_lock();	105
369		oh_lookup_next_handler(hid, &next_hid);	106
738		while (next_hid) {	107
369		hid = next_hid;	108
369		h = oh_lookup_handler(hid);	109
369		if (h->abi->discover_resources(h->hnd) == SA_OK && rv)	110
369		rv = SA_OK;	111
			112
369		oh_lookup_next_handler(hid, &next_hid);	113
		}	114
369		data_access_unlock();	115
			116
369		if (rv) {	117
0		dbg("Error attempting to discover resources in Domain %d",did);	118
0		return SA_ERR_HPI_UNKNOWN;	119
		}	120
			121
369		rv = oh_get_events();	122
			123
369		if (rv < 0) {	124
0		dbg("Error attempting to process resources in Domain %d",did);	125
0		return SA_ERR_HPI_UNKNOWN;	126
		}	127
			128
369		return SA_OK;	129
		}	130
			131
			132
		/*********************************************************************	133
		*	134
		* Domain Functions	135
		*	136
		********************************************************************/	137
			138
		SaErrorT SAHPI_API saHpiDomainInfoGet (	139
		SAHPI_IN SaHpiSessionIdT SessionId,	140
		SAHPI_OUT SaHpiDomainInfoT *DomainInfo)	141
151		{	142
151		SaHpiDomainIdT did;	143
151		struct oh_domain *d = NULL;	144
			145
151		if (!DomainInfo) return SA_ERR_HPI_INVALID_PARAMS;	146
			147
150		OH_CHECK_INIT_STATE(SessionId);	148
149		OH_GET_DID(SessionId, did);	149
			150
149		OH_GET_DOMAIN(did, d); /* Lock domain */	151
149		DomainInfo->DomainId = d->id;	152
149		DomainInfo->DomainCapabilities = d->capabilities;	153
149		DomainInfo->IsPeer = d->is_peer;	154
149		DomainInfo->RptUpdateCount = d->rpt.update_count;	155
149		DomainInfo->RptUpdateTimestamp = d->rpt.update_timestamp;	156
149		memcpy(DomainInfo->Guid, d->guid, sizeof(SaHpiGuidT));	157
149		DomainInfo->DomainTag = d->tag;	158
149		oh_release_domain(d); /* Unlock domain */	159
			160
149		return SA_OK;	161
		}	162
			163
		/***********************************************************	164
		*	165
		* For OpenHPI 2.0 this is always going to return	166
		* NOT_PRESENT unless it is called invalidly. True	167
		* DRT support won't be there until 2.2.	168
		*	169
		**********************************************************/	170
			171
		SaErrorT SAHPI_API saHpiDrtEntryGet (	172
		SAHPI_IN SaHpiSessionIdT SessionId,	173
		SAHPI_IN SaHpiEntryIdT EntryId,	174
		SAHPI_OUT SaHpiEntryIdT *NextEntryId,	175
		SAHPI_OUT SaHpiDrtEntryT *DrtEntry)	176
148		{	177
148		SaHpiDomainIdT did;	178
148		OH_CHECK_INIT_STATE(SessionId);	179
147		OH_GET_DID(SessionId, did);	180
			181
147		if((DrtEntry == NULL) ||	182
		(NextEntryId == NULL) ||	183
		(EntryId == SAHPI_LAST_ENTRY)) {	184
3		return SA_ERR_HPI_INVALID_PARAMS;	185
		}	186
			187
144		return SA_ERR_HPI_NOT_PRESENT;	188
		}	189
			190
		SaErrorT SAHPI_API saHpiDomainTagSet (	191
		SAHPI_IN SaHpiSessionIdT SessionId,	192
		SAHPI_IN SaHpiTextBufferT *DomainTag)	193
11		{	194
11		SaHpiDomainIdT did;	195
11		struct oh_domain *d = NULL;	196
			197
11		if (!DomainTag || !oh_valid_textbuffer(DomainTag))	198
4		return SA_ERR_HPI_INVALID_PARAMS;	199
			200
7		OH_CHECK_INIT_STATE(SessionId);	201
6		OH_GET_DID(SessionId, did);	202
			203
6		OH_GET_DOMAIN(did, d); /* Lock domain */	204
6		d->tag = *DomainTag;	205
6		oh_release_domain(d); /* Unlock domain */	206
			207
6		return SA_OK;	208
		}	209
			210
		/*********************************************************************	211
		*	212
		* Resource Functions	213
		*	214
		********************************************************************/	215
			216
		SaErrorT SAHPI_API saHpiRptEntryGet(	217
		SAHPI_IN SaHpiSessionIdT SessionId,	218
		SAHPI_IN SaHpiEntryIdT EntryId,	219
		SAHPI_OUT SaHpiEntryIdT *NextEntryId,	220
		SAHPI_OUT SaHpiRptEntryT *RptEntry)	221
701		{	222
701		SaHpiDomainIdT did;	223
701		struct oh_domain *d = NULL;	224
701		SaHpiRptEntryT *req_entry;	225
701		SaHpiRptEntryT *next_entry;	226
			227
701		OH_CHECK_INIT_STATE(SessionId);	228
700		OH_GET_DID(SessionId, did);	229
			230
		/* Test pointer parameters for invalid pointers */	231
700		if ((NextEntryId == NULL) || (RptEntry == NULL)) {	232
2		return SA_ERR_HPI_INVALID_PARAMS;	233
		}	234
			235
		/* I believe this is the only current reserved value	236
		here, though others may come in the future. */	237
698		if (EntryId == SAHPI_LAST_ENTRY) {	238
1		return SA_ERR_HPI_INVALID_PARAMS;	239
		}	240
			241
697		OH_GET_DOMAIN(did, d); /* Lock domain */	242
			243
697		if (EntryId == SAHPI_FIRST_ENTRY) {	244
288		req_entry = oh_get_resource_next(&(d->rpt), SAHPI_FIRST_ENTRY);	245
		} else {	246
409		req_entry = oh_get_resource_by_id(&(d->rpt), EntryId);	247
		}	248
			249
		/* if the entry was NULL, clearly have an issue */	250
697		if (req_entry == NULL) {	251
1		dbg("Invalid EntryId %d in Domain %d", EntryId, did);	252
1		oh_release_domain(d); /* Unlock domain */	253
1		return SA_ERR_HPI_NOT_PRESENT;	254
		}	255
			256
696		memcpy(RptEntry, req_entry, sizeof(*RptEntry));	257
			258
696		next_entry = oh_get_resource_next(&(d->rpt), req_entry->EntryId);	259
			260
696		if(next_entry != NULL) {	261
517		*NextEntryId = next_entry->EntryId;	262
		} else {	263
179		*NextEntryId = SAHPI_LAST_ENTRY;	264
		}	265
			266
696		oh_release_domain(d); /* Unlock domain */	267
			268
696		return SA_OK;	269
		}	270
			271
		SaErrorT SAHPI_API saHpiRptEntryGetByResourceId(	272
		SAHPI_IN SaHpiSessionIdT SessionId,	273
		SAHPI_IN SaHpiResourceIdT ResourceId,	274
		SAHPI_OUT SaHpiRptEntryT *RptEntry)	275
7		{	276
7		SaHpiDomainIdT did;	277
7		struct oh_domain *d = NULL;	278
7		SaHpiRptEntryT *req_entry;	279
			280
7		OH_CHECK_INIT_STATE(SessionId);	281
6		OH_GET_DID(SessionId, did);	282
			283
		/* Test pointer parameters for invalid pointers */	284
6		if (ResourceId == SAHPI_UNSPECIFIED_RESOURCE_ID ||	285
		RptEntry == NULL)	286
		{	287
1		return SA_ERR_HPI_INVALID_PARAMS;	288
		}	289
			290
5		OH_GET_DOMAIN(did, d); /* Lock domain */	291
			292
5		req_entry = oh_get_resource_by_id(&(d->rpt), ResourceId);	293
			294
		/*	295
		* is this case really supposed to be an error? I thought	296
		* there was a valid return for "not found in domain"	297
		*/	298
			299
5		if (req_entry == NULL) {	300
1		dbg("No such Resource Id %d in Domain %d", ResourceId, did);	301
1		oh_release_domain(d); /* Unlock domain */	302
1		return SA_ERR_HPI_INVALID_CMD;	303
		}	304
			305
4		memcpy(RptEntry, req_entry, sizeof(*RptEntry));	306
			307
4		oh_release_domain(d); /* Unlock domain */	308
			309
4		return SA_OK;	310
		}	311
			312
		SaErrorT SAHPI_API saHpiResourceSeveritySet(	313
		SAHPI_IN SaHpiSessionIdT SessionId,	314
		SAHPI_IN SaHpiResourceIdT ResourceId,	315
		SAHPI_IN SaHpiSeverityT Severity)	316
5		{	317
		/* this requires a new abi call to push down to the plugin */	318
		int (*set_res_sev)(void *hnd, SaHpiResourceIdT id,	319
5		SaHpiSeverityT sev);	320
			321
5		SaHpiDomainIdT did;	322
5		struct oh_handler *h = NULL;	323
5		struct oh_domain *d = NULL;	324
			325
5		OH_CHECK_INIT_STATE(SessionId);	326
			327
4		if (ResourceId == SAHPI_UNSPECIFIED_RESOURCE_ID) {	328
0		dbg("Invalid resource id, SAHPI_UNSPECIFIED_RESOURCE_ID passed.");	329
0		return SA_ERR_HPI_INVALID_PARAMS;	330
4		} else if (!oh_lookup_severity(Severity)) {	331
1		dbg("Invalid severity %d passed.", Severity);	332
1		return SA_ERR_HPI_INVALID_PARAMS;	333
		}	334
			335
3		OH_GET_DID(SessionId, did);	336
			337
3		OH_GET_DOMAIN(did, d); /* Lock domain */	338
			339
3		OH_HANDLER_GET(d, ResourceId, h);	340
2		oh_release_domain(d); /* Unlock domain */	341
			342
2		set_res_sev = h->abi->set_resource_severity;	343
			344
2		if (!set_res_sev) {	345
2		return SA_ERR_HPI_INVALID_CMD;	346
		}	347
			348
0		if (set_res_sev(h->hnd, ResourceId, Severity) < 0) {	349
0		dbg("Setting severity failed for ResourceId %d in Domain %d",	350
		ResourceId, did);	351
0		return SA_ERR_HPI_UNKNOWN;	352
		}	353
			354
		/* to get rpt entry into infrastructure */	355
0		oh_get_events();	356
			357
0		return SA_OK;	358
		}	359
			360
		SaErrorT SAHPI_API saHpiResourceTagSet(	361
		SAHPI_IN SaHpiSessionIdT SessionId,	362
		SAHPI_IN SaHpiResourceIdT ResourceId,	363
		SAHPI_IN SaHpiTextBufferT *ResourceTag)	364
11		{	365
11		SaErrorT rv;	366
		SaErrorT (*set_res_tag)(void *hnd, SaHpiResourceIdT id,	367
11		SaHpiTextBufferT *ResourceTag);	368
			369
11		SaHpiDomainIdT did;	370
11		struct oh_handler *h = NULL;	371
11		struct oh_domain *d = NULL;	372
11		SaHpiRptEntryT *rptentry;	373
			374
11		OH_CHECK_INIT_STATE(SessionId);	375
10		OH_GET_DID(SessionId, did);	376
			377
10		OH_GET_DOMAIN(did, d); /* Lock domain */	378
10		OH_HANDLER_GET(d, ResourceId, h);	379
9		oh_release_domain(d); /* Unlock domain */	380
			381
9		set_res_tag = h->abi->set_resource_tag;	382
			383
9		if (!set_res_tag) {	384
9		return SA_ERR_HPI_INVALID_CMD;	385
		}	386
			387
0		rv = set_res_tag(h->hnd, ResourceId, ResourceTag);	388
0		if (rv != SA_OK) {	389
0		dbg("Tag set failed for Resource %d in Domain %d",	390
		ResourceId, did);	391
0		return rv;	392
		}	393
			394
0		OH_GET_DOMAIN(did, d); /* Lock domain */	395
0		rptentry = oh_get_resource_by_id(&(d->rpt), ResourceId);	396
0		if (!rptentry) {	397
0		dbg("Tag set failed: No Resource %d in Domain %d",	398
		ResourceId, did);	399
0		oh_release_domain(d); /* Unlock domain */	400
0		return SA_ERR_HPI_NOT_PRESENT;	401
		}	402
0		rptentry->ResourceTag = *ResourceTag;	403
0		oh_release_domain(d); /* Unlock domain */	404
			405
0		return SA_OK;	406
		}	407
			408
		SaErrorT SAHPI_API saHpiResourceIdGet(	409
		SAHPI_IN SaHpiSessionIdT SessionId,	410
		SAHPI_OUT SaHpiResourceIdT *ResourceId)	411
3		{	412
3		SaHpiDomainIdT did;	413
3		struct oh_domain *d = NULL;	414
3		SaHpiRptEntryT *rptentry;	415
3		struct oh_global_param ep_param = { .type = OPENHPI_ON_EP };	416
			417
3		OH_CHECK_INIT_STATE(SessionId);	418
2		OH_GET_DID(SessionId, did);	419
			420
2		oh_get_global_param(&ep_param);	421
			422
2		OH_GET_DOMAIN(did, d); /* Lock domain */	423
2		rptentry = oh_get_resource_by_ep(&(d->rpt), &ep_param.u.on_ep);	424
2		if (!rptentry) {	425
2		oh_release_domain(d); /* Unlock domain */	426
2		return SA_ERR_HPI_NOT_PRESENT;	427
		}	428
			429
0		*ResourceId = rptentry->ResourceId;	430
0		oh_release_domain(d); /* Unlock domain */	431
			432
0		return SA_OK;	433
		}	434
			435
		/*********************************************************************	436
		*	437
		* Event Log Functions	438
		*	439
		********************************************************************/	440
			441
		SaErrorT SAHPI_API saHpiEventLogInfoGet (	442
		SAHPI_IN SaHpiSessionIdT SessionId,	443
		SAHPI_IN SaHpiResourceIdT ResourceId,	444
		SAHPI_OUT SaHpiEventLogInfoT *Info)	445
22		{	446
22		SaErrorT rv;	447
22		SaErrorT (*get_func) (void *, SaHpiResourceIdT, SaHpiEventLogInfoT *);	448
22		SaHpiRptEntryT *res;	449
22		struct oh_handler *h = NULL;	450
22		struct oh_domain *d = NULL;	451
22		SaHpiDomainIdT did;	452
			453
		/* Test pointer parameters for invalid pointers */	454
22		if (Info == NULL)	455
		{	456
1		return SA_ERR_HPI_INVALID_PARAMS;	457
		}	458
			459
21		OH_CHECK_INIT_STATE(SessionId);	460
18		OH_GET_DID(SessionId, did);	461
18		OH_GET_DOMAIN(did, d); /* Lock domain */	462
			463
		/* test for special domain case */	464
18		if (ResourceId == SAHPI_UNSPECIFIED_RESOURCE_ID) {	465
10		rv = oh_el_info(d->del, Info);	466
10		oh_release_domain(d); /* Unlock domain */	467
10		return rv;	468
		}	469
			470
8		OH_RESOURCE_GET(d, ResourceId, res);	471
			472
5		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_EVENT_LOG)) {	473
3		dbg("Resource %d in Domain %d does not have EL",ResourceId,did);	474
3		oh_release_domain(d); /* Unlock domain */	475
3		return SA_ERR_HPI_CAPABILITY;	476
		}	477
			478
2		OH_HANDLER_GET(d, ResourceId, h);	479
2		oh_release_domain(d); /* Unlock domain */	480
			481
2		get_func = h->abi->get_el_info;	482
			483
2		if (!get_func) {	484
0		return SA_ERR_HPI_INVALID_CMD;	485
		}	486
			487
2		rv = get_func(h->hnd, ResourceId, Info);	488
			489
2		if (rv != SA_OK) {	490
0		dbg("EL info get failed");	491
		}	492
			493
2		return rv;	494
		}	495
			496
		SaErrorT SAHPI_API saHpiEventLogEntryGet (	497
		SAHPI_IN SaHpiSessionIdT SessionId,	498
		SAHPI_IN SaHpiResourceIdT ResourceId,	499
		SAHPI_IN SaHpiEventLogEntryIdT EntryId,	500
		SAHPI_OUT SaHpiEventLogEntryIdT *PrevEntryId,	501
		SAHPI_OUT SaHpiEventLogEntryIdT *NextEntryId,	502
		SAHPI_OUT SaHpiEventLogEntryT *EventLogEntry,	503
		SAHPI_INOUT SaHpiRdrT *Rdr,	504
		SAHPI_INOUT SaHpiRptEntryT *RptEntry)	505
32		{	506
32		SaErrorT rv;	507
		SaErrorT (*get_el_entry)(void *hnd, SaHpiResourceIdT id,	508
		SaHpiEventLogEntryIdT current,	509
		SaHpiEventLogEntryIdT *prev,	510
		SaHpiEventLogEntryIdT *next,	511
		SaHpiEventLogEntryT *entry,	512
		SaHpiRdrT *rdr,	513
32		SaHpiRptEntryT *rptentry);	514
			515
32		SaHpiRptEntryT *res;	516
32		struct oh_handler *h;	517
32		struct oh_domain *d;	518
32		oh_el_entry *elentry;	519
32		SaErrorT retc;	520
32		SaHpiDomainIdT did;	521
			522
		/* Test pointer parameters for invalid pointers */	523
32		if (!PrevEntryId || !EventLogEntry || !NextEntryId ||	524
		EntryId == SAHPI_NO_MORE_ENTRIES)	525
		{	526
4		return SA_ERR_HPI_INVALID_PARAMS;	527
		}	528
			529
28		OH_CHECK_INIT_STATE(SessionId);	530
27		OH_GET_DID(SessionId, did);	531
27		OH_GET_DOMAIN(did, d); /* Lock domain */	532
			533
		/* test for special domain case */	534
27		if (ResourceId == SAHPI_UNSPECIFIED_RESOURCE_ID) {	535
24		retc = oh_el_get(d->del, EntryId, PrevEntryId, NextEntryId,	536
		&elentry);	537
24		if (retc == SA_OK) {	538
24		memcpy(EventLogEntry, &elentry->event, sizeof(SaHpiEventLogEntryT));	539
24		if (Rdr)	540
24		memcpy(Rdr, &elentry->rdr, sizeof(SaHpiRdrT));	541
24		if (RptEntry)	542
24		memcpy(RptEntry, &elentry->res, sizeof(SaHpiRptEntryT));	543
		}	544
24		oh_release_domain(d); /* Unlock domain */	545
24		return retc;	546
		}	547
			548
3		OH_RESOURCE_GET(d, ResourceId, res);	549
			550
2		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_EVENT_LOG)) {	551
1		dbg("Resource %d in Domain %d does not have EL",ResourceId,did);	552
1		oh_release_domain(d); /* Unlock domain */	553
1		return SA_ERR_HPI_CAPABILITY;	554
		}	555
			556
1		OH_HANDLER_GET(d, ResourceId, h);	557
1		oh_release_domain(d); /* Unlock domain */	558
			559
1		get_el_entry = h->abi->get_el_entry;	560
			561
1		if (!get_el_entry) {	562
0		dbg("This api is not supported");	563
0		return SA_ERR_HPI_INVALID_CMD;	564
		}	565
			566
1		rv = get_el_entry(h->hnd, ResourceId,	567
		EntryId, PrevEntryId,	568
		NextEntryId, EventLogEntry,	569
		Rdr, RptEntry);	570
			571
1		if(rv != SA_OK)	572
1		dbg("EL entry get failed\n");	573
			574
1		return rv;	575
		}	576
			577
		SaErrorT SAHPI_API saHpiEventLogEntryAdd (	578
		SAHPI_IN SaHpiSessionIdT SessionId,	579
		SAHPI_IN SaHpiResourceIdT ResourceId,	580
		SAHPI_IN SaHpiEventT *EvtEntry)	581
10		{	582
10		SaErrorT rv;	583
		SaErrorT (*add_el_entry)(void *hnd, SaHpiResourceIdT id,	584
10		const SaHpiEventT *Event);	585
10		SaHpiRptEntryT *res;	586
10		struct oh_handler *h;	587
10		struct oh_domain *d;	588
10		SaHpiDomainIdT did;	589
			590
10		OH_CHECK_INIT_STATE(SessionId);	591
			592
9		if (EvtEntry == NULL ||	593
		EvtEntry->EventType != SAHPI_ET_USER ||	594
		EvtEntry->Source != SAHPI_UNSPECIFIED_RESOURCE_ID ||	595
		!oh_lookup_severity(EvtEntry->Severity) ||	596
		!oh_valid_textbuffer(&(EvtEntry->EventDataUnion.UserEvent.UserEventData))) {	597
8		return SA_ERR_HPI_INVALID_PARAMS;	598
		}	599
			600
1		OH_GET_DID(SessionId, did);	601
1		OH_GET_DOMAIN(did, d); /* Lock domain */	602
			603
		/* test for special domain case */	604
1		if (ResourceId == SAHPI_UNSPECIFIED_RESOURCE_ID) {	605
1		rv = oh_el_append(d->del, EvtEntry, NULL, NULL);	606
1		oh_release_domain(d); /* Unlock domain */	607
1		return rv;	608
		}	609
			610
0		OH_RESOURCE_GET(d, ResourceId, res);	611
			612
0		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_EVENT_LOG)) {	613
0		dbg("Resource %d in Domain %d does not have EL.",ResourceId,did);	614
0		oh_release_domain(d); /* Unlock domain */	615
0		return SA_ERR_HPI_CAPABILITY;	616
		}	617
			618
0		OH_HANDLER_GET(d, ResourceId, h);	619
0		oh_release_domain(d); /* Unlock domain */	620
			621
0		add_el_entry = h->abi->add_el_entry;	622
			623
0		if (!add_el_entry) {	624
0		return SA_ERR_HPI_INVALID_CMD;	625
		}	626
			627
0		rv = add_el_entry(h->hnd, ResourceId, EvtEntry);	628
0		if(rv != SA_OK) {	629
0		dbg("EL add entry failed");	630
		}	631
			632
			633
		/* to get REL entry into infrastructure */	634
0		rv = oh_get_events();	635
0		if(rv != SA_OK) {	636
0		dbg("Event loop failed");	637
		}	638
			639
0		return rv;	640
		}	641
			642
		SaErrorT SAHPI_API saHpiEventLogClear (	643
		SAHPI_IN SaHpiSessionIdT SessionId,	644
		SAHPI_IN SaHpiResourceIdT ResourceId)	645
4		{	646
4		SaErrorT rv;	647
4		SaErrorT (*clear_el)(void *hnd, SaHpiResourceIdT id);	648
4		SaHpiRptEntryT *res;	649
4		struct oh_handler *h;	650
4		struct oh_domain *d;	651
4		SaHpiDomainIdT did;	652
			653
			654
4		OH_CHECK_INIT_STATE(SessionId);	655
3		OH_GET_DID(SessionId, did);	656
3		OH_GET_DOMAIN(did, d); /* Lock domain */	657
			658
		/* test for special domain case */	659
3		if (ResourceId == SAHPI_UNSPECIFIED_RESOURCE_ID) {	660
1		rv = oh_el_clear(d->del);	661
1		oh_release_domain(d); /* Unlock domain */	662
1		return rv;	663
		}	664
			665
2		OH_RESOURCE_GET(d, ResourceId, res);	666
			667
1		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_EVENT_LOG)) {	668
1		dbg("Resource %d in Domain %d does not have EL",ResourceId,did);	669
1		oh_release_domain(d); /* Unlock domain */	670
1		return SA_ERR_HPI_CAPABILITY;	671
		}	672
			673
0		OH_HANDLER_GET(d, ResourceId, h);	674
0		oh_release_domain(d); /* Unlock domain */	675
			676
0		clear_el = h->abi->clear_el;	677
0		if (!clear_el) {	678
0		return SA_ERR_HPI_INVALID_CMD;	679
		}	680
			681
0		rv = clear_el(h->hnd, ResourceId);	682
0		if(rv != SA_OK) {	683
0		dbg("EL delete entry failed");	684
		}	685
			686
0		return rv;	687
		}	688
			689
		SaErrorT SAHPI_API saHpiEventLogTimeGet (	690
		SAHPI_IN SaHpiSessionIdT SessionId,	691
		SAHPI_IN SaHpiResourceIdT ResourceId,	692
		SAHPI_OUT SaHpiTimeT *Time)	693
8		{	694
8		SaHpiEventLogInfoT info;	695
8		SaErrorT rv;	696
			697
		/* Test pointer parameters for invalid pointers */	698
8		if (Time == NULL)	699
		{	700
1		return SA_ERR_HPI_INVALID_PARAMS;	701
		}	702
			703
7		rv = saHpiEventLogInfoGet(SessionId, ResourceId, &info);	704
			705
7		if(rv != SA_OK) {	706
3		return rv;	707
		}	708
			709
4		*Time = info.CurrentTime;	710
			711
4		return SA_OK;	712
		}	713
			714
		SaErrorT SAHPI_API saHpiEventLogTimeSet (	715
		SAHPI_IN SaHpiSessionIdT SessionId,	716
		SAHPI_IN SaHpiResourceIdT ResourceId,	717
		SAHPI_IN SaHpiTimeT Time)	718
10		{	719
10		SaErrorT rv;	720
10		SaErrorT (*set_el_time)(void *hnd, SaHpiResourceIdT id, SaHpiTimeT time);	721
10		SaHpiRptEntryT *res;	722
10		struct oh_handler *h;	723
10		struct oh_domain *d;	724
10		SaHpiDomainIdT did;	725
			726
10		OH_CHECK_INIT_STATE(SessionId);	727
9		OH_GET_DID(SessionId, did);	728
9		OH_GET_DOMAIN(did, d); /* Lock domain */	729
			730
		/* test for special domain case */	731
9		if (ResourceId == SAHPI_UNSPECIFIED_RESOURCE_ID) {	732
6		rv = oh_el_timeset(d->del, Time);	733
6		oh_release_domain(d); /* Unlock domain */	734
6		return rv;	735
		}	736
			737
3		OH_RESOURCE_GET(d, ResourceId, res);	738
			739
2		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_EVENT_LOG)) {	740
2		dbg("Resource %d in Domain %d does not have EL",ResourceId,did);	741
2		oh_release_domain(d); /* Unlock domain */	742
2		return SA_ERR_HPI_CAPABILITY;	743
		}	744
			745
0		OH_HANDLER_GET(d, ResourceId, h);	746
0		oh_release_domain(d); /* Unlock domain */	747
			748
0		set_el_time = h->abi->set_el_time;	749
			750
0		if (!set_el_time) {	751
0		return SA_ERR_HPI_INVALID_CMD;	752
		}	753
			754
0		rv = set_el_time(h->hnd, ResourceId, Time);	755
0		if(rv != SA_OK) {	756
0		dbg("Set EL time failed");	757
		}	758
			759
0		return rv;	760
		}	761
			762
		SaErrorT SAHPI_API saHpiEventLogStateGet (	763
		SAHPI_IN SaHpiSessionIdT SessionId,	764
		SAHPI_IN SaHpiResourceIdT ResourceId,	765
		SAHPI_OUT SaHpiBoolT *Enable)	766
9		{	767
9		SaHpiEventLogInfoT info;	768
9		SaErrorT rv;	769
			770
		/* Test pointer parameters for invalid pointers */	771
9		if (Enable == NULL)	772
		{	773
1		return SA_ERR_HPI_INVALID_PARAMS;	774
		}	775
			776
8		rv = saHpiEventLogInfoGet(SessionId, ResourceId, &info);	777
			778
8		if(rv != SA_OK) {	779
3		return rv;	780
		}	781
			782
5		*Enable = info.Enabled;	783
			784
5		return SA_OK;	785
		}	786
			787
		SaErrorT SAHPI_API saHpiEventLogStateSet (	788
		SAHPI_IN SaHpiSessionIdT SessionId,	789
		SAHPI_IN SaHpiResourceIdT ResourceId,	790
		SAHPI_IN SaHpiBoolT Enable)	791
9		{	792
9		struct oh_domain *d;	793
9		SaHpiDomainIdT did;	794
9		SaHpiRptEntryT *res;	795
			796
9		OH_CHECK_INIT_STATE(SessionId);	797
8		OH_GET_DID(SessionId, did);	798
8		OH_GET_DOMAIN(did, d); /* Lock domain */	799
			800
		/* test for special domain case */	801
8		if (ResourceId == SAHPI_UNSPECIFIED_RESOURCE_ID) {	802
6		d->del->enabled = Enable;	803
6		oh_release_domain(d); /* Unlock domain */	804
6		return SA_OK;	805
		}	806
			807
2		OH_RESOURCE_GET(d, ResourceId, res);	808
			809
1		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_EVENT_LOG)) {	810
1		dbg("Resource %d in Domain %d does not have EL",ResourceId,did);	811
1		oh_release_domain(d); /* Unlock domain */	812
1		return SA_ERR_HPI_CAPABILITY;	813
		} else {	814
0		oh_release_domain(d); /* Unlock domain */	815
		/* FIXME: Need to add set_el_state abi call */	816
0		return SA_ERR_HPI_UNSUPPORTED_API;	817
		}	818
		}	819
			820
		SaErrorT SAHPI_API saHpiEventLogOverflowReset (	821
		SAHPI_IN SaHpiSessionIdT SessionId,	822
		SAHPI_IN SaHpiResourceIdT ResourceId)	823
2		{	824
2		return SA_ERR_HPI_UNSUPPORTED_API;	825
		}	826
			827
		/*********************************************************************	828
		*	829
		* Event Functions	830
		*	831
		********************************************************************/	832
			833
		SaErrorT SAHPI_API saHpiSubscribe (	834
		SAHPI_IN SaHpiSessionIdT SessionId)	835
12		{	836
12		SaHpiDomainIdT did;	837
12		SaHpiBoolT session_state;	838
12		SaErrorT error;	839
			840
12		OH_CHECK_INIT_STATE(SessionId);	841
11		OH_GET_DID(SessionId, did);	842
			843
11		error = oh_get_session_subscription(SessionId, &session_state);	844
11		if (error) {	845
0		dbg("Error subscribing to SessionId: %d", SessionId);	846
0		return error;	847
		}	848
			849
11		if (session_state != OH_UNSUBSCRIBED) {	850
1		dbg("Cannot subscribe if session is not unsubscribed.");	851
1		return SA_ERR_HPI_DUPLICATE;	852
		}	853
			854
10		error = oh_set_session_subscription(SessionId, SAHPI_TRUE);	855
			856
10		return error;	857
		}	858
			859
		SaErrorT SAHPI_API saHpiUnsubscribe (	860
		SAHPI_IN SaHpiSessionIdT SessionId)	861
11		{	862
11		SaHpiDomainIdT did;	863
11		SaHpiBoolT session_state;	864
11		SaErrorT error;	865
11		SaErrorT terror = SA_OK;	866
11		struct oh_event event;	867
			868
11		OH_CHECK_INIT_STATE(SessionId);	869
10		OH_GET_DID(SessionId, did);	870
			871
10		error = oh_get_session_subscription(SessionId, &session_state);	872
10		if (error) {	873
0		dbg("Error reading session subscription from SessionId: %d", SessionId);	874
0		return error;	875
		}	876
			877
10		if (session_state == OH_UNSUBSCRIBED) {	878
1		dbg("Cannot unsubscribe if session is not subscribed.");	879
1		return SA_ERR_HPI_INVALID_REQUEST;	880
		}	881
			882
9		error = oh_set_session_subscription(SessionId, SAHPI_FALSE);	883
9		if (error) {	884
0		dbg("Error unsubscribing to SessionId: %d", SessionId);	885
0		return error;	886
		}	887
			888
		/* Flush session's event queue	889
		* we use a temp error variable as the dequeue loop signals an	890
		* end via a TIMEOUT error. If it is anything else, we assign it	891
		* to the return value.	892
		*/	893
			894
9		error = SA_OK;	895
			896
18		while (terror == SA_OK) {	897
9		terror = oh_dequeue_session_event(SessionId,	898
		SAHPI_TIMEOUT_IMMEDIATE,	899
		&event);	900
		}	901
			902
9		if(terror != SA_ERR_HPI_TIMEOUT) {	903
0		dbg("Unexpected error occured in clearing the event queues");	904
0		error = terror;	905
		}	906
			907
9		return error;	908
		}	909
			910
		SaErrorT SAHPI_API saHpiEventGet (	911
		SAHPI_IN SaHpiSessionIdT SessionId,	912
		SAHPI_IN SaHpiTimeoutT Timeout,	913
		SAHPI_OUT SaHpiEventT *Event,	914
		SAHPI_INOUT SaHpiRdrT *Rdr,	915
		SAHPI_INOUT SaHpiRptEntryT *RptEntry,	916
		SAHPI_INOUT SaHpiEvtQueueStatusT *EventQueueStatus)	917
6		{	918
			919
6		SaHpiDomainIdT did;	920
6		SaHpiBoolT session_state;	921
6		struct oh_event e;	922
6		SaErrorT error;	923
			924
6		OH_CHECK_INIT_STATE(SessionId);	925
5		OH_GET_DID(SessionId, did);	926
			927
5		if (Timeout < SAHPI_TIMEOUT_BLOCK || !Event) {	928
1		return SA_ERR_HPI_INVALID_PARAMS;	929
		}	930
			931
4		if( !oh_run_threaded() && Timeout != SAHPI_TIMEOUT_IMMEDIATE) {	932
3		dbg("Can not support timeouts in non threaded mode");	933
3		return SA_ERR_HPI_INVALID_PARAMS;	934
		}	935
			936
1		error = oh_get_session_subscription(SessionId, &session_state);	937
1		if (error) return error;	938
			939
1		if (session_state != OH_SUBSCRIBED) {	940
0		return SA_ERR_HPI_INVALID_REQUEST;	941
		}	942
			943
1		if ( !oh_run_threaded() ) {	944
1		error = oh_get_events();	945
1		if (error < 0) return SA_ERR_HPI_UNKNOWN;	946
		}	947
			948
1		error = oh_dequeue_session_event(SessionId, Timeout, &e);	949
1		if (error) return error;	950
			951
		/* Return event, resource and rdr */	952
0		*Event = e.u.hpi_event.event;	953
			954
		/* EventQueueStatus may be NULL if you don't care */	955
0		if(EventQueueStatus) {	956
0		*EventQueueStatus = 0x0000;	957
		}	958
			959
0		if (RptEntry && e.u.hpi_event.res.ResourceId != 0) {	960
0		*RptEntry = e.u.hpi_event.res;	961
		}	962
			963
0		if (Rdr && e.u.hpi_event.rdr.RecordId != 0) {	964
0		*Rdr = e.u.hpi_event.rdr;	965
		}	966
			967
0		return SA_OK;	968
		}	969
			970
		SaErrorT SAHPI_API saHpiEventAdd (	971
		SAHPI_IN SaHpiSessionIdT SessionId,	972
		SAHPI_IN SaHpiEventT *EvtEntry)	973
9		{	974
9		SaHpiDomainIdT did;	975
9		struct oh_event e;	976
9		GArray *session_list = NULL;	977
9		SaErrorT error;	978
9		unsigned int i;	979
			980
9		error = oh_valid_addevent(EvtEntry);	981
9		if (error) return(error);	982
			983
2		OH_CHECK_INIT_STATE(SessionId);	984
2		OH_GET_DID(SessionId, did);	985
			986
2		e.did = did;	987
2		e.hid = 0;	988
2		e.type = OH_ET_HPI;	989
2		e.u.hpi_event.event = *EvtEntry;	990
			991
2		session_list = oh_list_sessions(did);	992
4		for (i = 0; i < session_list->len; i++) {	993
2		error = oh_queue_session_event(SessionId, &e);	994
2		if (error) break;	995
		}	996
2		g_array_free(session_list, TRUE);	997
			998
2		return error;	999
		}	1000
			1001
		/*********************************************************************	1002
		*	1003
		* DAT Functions	1004
		*	1005
		********************************************************************/	1006
			1007
		SaErrorT SAHPI_API saHpiAlarmGetNext (	1008
		SAHPI_IN SaHpiSessionIdT SessionId,	1009
		SAHPI_IN SaHpiSeverityT Severity,	1010
		SAHPI_IN SaHpiBoolT UnacknowledgedOnly,	1011
		SAHPI_INOUT SaHpiAlarmT *Alarm)	1012
0		{	1013
0		return SA_ERR_HPI_UNSUPPORTED_API;	1014
		}	1015
			1016
		SaErrorT SAHPI_API saHpiAlarmGet(	1017
		SAHPI_IN SaHpiSessionIdT SessionId,	1018
		SAHPI_IN SaHpiAlarmIdT AlarmId,	1019
		SAHPI_OUT SaHpiAlarmT *Alarm)	1020
0		{	1021
0		return SA_ERR_HPI_UNSUPPORTED_API;	1022
		}	1023
			1024
		SaErrorT SAHPI_API saHpiAlarmAcknowledge(	1025
		SAHPI_IN SaHpiSessionIdT SessionId,	1026
		SAHPI_IN SaHpiAlarmIdT AlarmId,	1027
		SAHPI_IN SaHpiSeverityT Severity)	1028
0		{	1029
0		return SA_ERR_HPI_UNSUPPORTED_API;	1030
		}	1031
			1032
		SaErrorT SAHPI_API saHpiAlarmAdd(	1033
		SAHPI_IN SaHpiSessionIdT SessionId,	1034
		SAHPI_INOUT SaHpiAlarmT *Alarm)	1035
0		{	1036
0		return SA_ERR_HPI_UNSUPPORTED_API;	1037
		}	1038
			1039
		SaErrorT SAHPI_API saHpiAlarmDelete(	1040
		SAHPI_IN SaHpiSessionIdT SessionId,	1041
		SAHPI_IN SaHpiAlarmIdT AlarmId,	1042
		SAHPI_IN SaHpiSeverityT Severity)	1043
0		{	1044
0		return SA_ERR_HPI_UNSUPPORTED_API;	1045
		}	1046
			1047
		/*********************************************************************	1048
		*	1049
		* RDR Functions	1050
		*	1051
		********************************************************************/	1052
			1053
		SaErrorT SAHPI_API saHpiRdrGet (	1054
		SAHPI_IN SaHpiSessionIdT SessionId,	1055
		SAHPI_IN SaHpiResourceIdT ResourceId,	1056
		SAHPI_IN SaHpiEntryIdT EntryId,	1057
		SAHPI_OUT SaHpiEntryIdT *NextEntryId,	1058
		SAHPI_OUT SaHpiRdrT *Rdr)	1059
830		{	1060
830		struct oh_domain *d;	1061
830		SaHpiDomainIdT did;	1062
830		SaHpiRptEntryT *res = NULL;	1063
830		SaHpiRdrT *rdr_cur;	1064
830		SaHpiRdrT *rdr_next;	1065
			1066
830		OH_CHECK_INIT_STATE(SessionId);	1067
828		OH_GET_DID(SessionId, did);	1068
			1069
		/* Test pointer parameters for invalid pointers */	1070
828		if (EntryId == SAHPI_LAST_ENTRY || !Rdr || !NextEntryId)	1071
		{	1072
2		return SA_ERR_HPI_INVALID_PARAMS;	1073
		}	1074
			1075
826		OH_GET_DOMAIN(did, d); /* Lock domain */	1076
			1077
826		OH_RESOURCE_GET(d, ResourceId, res);	1078
			1079
825		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_RDR)) {	1080
12		dbg("No RDRs for Resource %d in Domain %d",ResourceId,did);	1081
12		oh_release_domain(d); /* Unlock domain */	1082
12		return SA_ERR_HPI_CAPABILITY;	1083
		}	1084
			1085
813		if(EntryId == SAHPI_FIRST_ENTRY) {	1086
217		rdr_cur = oh_get_rdr_next(&(d->rpt), ResourceId, SAHPI_FIRST_ENTRY);	1087
		} else {	1088
596		rdr_cur = oh_get_rdr_by_id(&(d->rpt), ResourceId, EntryId);	1089
		}	1090
			1091
813		if (rdr_cur == NULL) {	1092
1		dbg("Requested RDR, Domain[%d]->Resource[%d]->RDR[%d], is not present",	1093
		did, ResourceId, EntryId);	1094
1		oh_release_domain(d); /* Unlock domain */	1095
1		return SA_ERR_HPI_NOT_PRESENT;	1096
		}	1097
			1098
812		memcpy(Rdr, rdr_cur, sizeof(*Rdr));	1099
			1100
812		rdr_next = oh_get_rdr_next(&(d->rpt), ResourceId, rdr_cur->RecordId);	1101
812		if(rdr_next == NULL) {	1102
149		*NextEntryId = SAHPI_LAST_ENTRY;	1103
		} else {	1104
663		*NextEntryId = rdr_next->RecordId;	1105
		}	1106
			1107
812		oh_release_domain(d); /* Unlock domain */	1108
			1109
812		return SA_OK;	1110
		}	1111
			1112
		SaErrorT SAHPI_API saHpiRdrGetByInstrumentId (	1113
		SAHPI_IN SaHpiSessionIdT SessionId,	1114
		SAHPI_IN SaHpiResourceIdT ResourceId,	1115
		SAHPI_IN SaHpiRdrTypeT RdrType,	1116
		SAHPI_IN SaHpiInstrumentIdT InstrumentId,	1117
		SAHPI_OUT SaHpiRdrT *Rdr)	1118
0		{	1119
0		SaHpiRptEntryT *res = NULL;	1120
0		SaHpiRdrT *rdr_cur;	1121
0		SaHpiDomainIdT did;	1122
0		struct oh_domain *d = NULL;	1123
			1124
		/* Test pointer parameters for invalid pointers */	1125
0		if (!oh_lookup_rdrtype(RdrType) ||	1126
		RdrType == SAHPI_NO_RECORD || !Rdr)	1127
		{	1128
0		return SA_ERR_HPI_INVALID_PARAMS;	1129
		}	1130
			1131
0		OH_CHECK_INIT_STATE(SessionId);	1132
0		OH_GET_DID(SessionId, did);	1133
0		OH_GET_DOMAIN(did, d); /* Lock domain */	1134
			1135
0		OH_RESOURCE_GET(d, ResourceId, res);	1136
			1137
0		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_RDR)) {	1138
0		dbg("No RDRs for Resource %d in Domain %d",ResourceId,did);	1139
0		oh_release_domain(d); /* Unlock domain */	1140
0		return SA_ERR_HPI_CAPABILITY;	1141
		}	1142
			1143
0		rdr_cur = oh_get_rdr_by_type(&(d->rpt), ResourceId, RdrType, InstrumentId);	1144
			1145
0		if (rdr_cur == NULL) {	1146
0		dbg("Requested RDR, Domain[%d]->Resource[%d]->RDR[%d,%d], is not present",	1147
		did, ResourceId, RdrType, InstrumentId);	1148
0		oh_release_domain(d); /* Unlock domain */	1149
0		return SA_ERR_HPI_NOT_PRESENT;	1150
		}	1151
0		memcpy(Rdr, rdr_cur, sizeof(*Rdr));	1152
0		oh_release_domain(d); /* Unlock domain */	1153
			1154
			1155
0		return SA_OK;	1156
		}	1157
			1158
		/*********************************************************************	1159
		*	1160
		* Sensor Functions	1161
		*	1162
		********************************************************************/	1163
			1164
		SaErrorT SAHPI_API saHpiSensorReadingGet (	1165
		SAHPI_IN SaHpiSessionIdT SessionId,	1166
		SAHPI_IN SaHpiResourceIdT ResourceId,	1167
		SAHPI_IN SaHpiSensorNumT SensorNum,	1168
		SAHPI_INOUT SaHpiSensorReadingT *Reading,	1169
		SAHPI_INOUT SaHpiEventStateT *EventState)	1170
1		{	1171
1		SaErrorT rv;	1172
		SaErrorT (*get_func) (void *, SaHpiResourceIdT, SaHpiSensorNumT,	1173
1		SaHpiSensorReadingT *, SaHpiEventStateT *);	1174
			1175
1		struct oh_handler *h;	1176
1		SaHpiRptEntryT *res;	1177
1		SaHpiRdrT *rdr;	1178
1		SaHpiDomainIdT did;	1179
1		struct oh_domain *d = NULL;	1180
			1181
1		OH_CHECK_INIT_STATE(SessionId);	1182
1		OH_GET_DID(SessionId, did);	1183
1		OH_GET_DOMAIN(did, d); /* Lock domain */	1184
1		OH_RESOURCE_GET(d, ResourceId, res);	1185
			1186
1		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_SENSOR)) {	1187
1		dbg("Resource %d in Domain %d doesn't have sensors",	1188
		ResourceId, did);	1189
1		oh_release_domain(d); /* Unlock domain */	1190
1		return SA_ERR_HPI_CAPABILITY;	1191
		}	1192
			1193
0		rdr = oh_get_rdr_by_type(&(d->rpt), ResourceId, SAHPI_SENSOR_RDR, SensorNum);	1194
			1195
0		if (!rdr) {	1196
0		dbg("No Sensor %d found for ResourceId %d in Domain %d",	1197
		SensorNum, ResourceId, did);	1198
0		oh_release_domain(d); /* Unlock domain */	1199
0		return SA_ERR_HPI_NOT_PRESENT;	1200
		}	1201
			1202
0		OH_HANDLER_GET(d, ResourceId, h);	1203
0		oh_release_domain(d); /* Unlock domain */	1204
			1205
0		get_func = h->abi->get_sensor_reading;	1206
			1207
0		if (!get_func) {	1208
0		return SA_ERR_HPI_INVALID_CMD;	1209
		}	1210
			1211
0		rv = get_func(h->hnd, ResourceId, SensorNum, Reading, EventState);	1212
			1213
0		return rv;	1214
		}	1215
			1216
		SaErrorT SAHPI_API saHpiSensorThresholdsGet (	1217
		SAHPI_IN SaHpiSessionIdT SessionId,	1218
		SAHPI_IN SaHpiResourceIdT ResourceId,	1219
		SAHPI_IN SaHpiSensorNumT SensorNum,	1220
		SAHPI_IN SaHpiSensorThresholdsT *SensorThresholds)	1221
19		{	1222
19		SaErrorT rv;	1223
		SaErrorT (*get_func) (void *, SaHpiResourceIdT, SaHpiSensorNumT,	1224
19		SaHpiSensorThresholdsT *);	1225
19		SaHpiRptEntryT *res;	1226
19		struct oh_handler *h;	1227
19		SaHpiDomainIdT did;	1228
19		struct oh_domain *d = NULL;	1229
			1230
19		if (!SensorThresholds) return SA_ERR_HPI_INVALID_PARAMS;	1231
			1232
17		OH_CHECK_INIT_STATE(SessionId);	1233
15		OH_GET_DID(SessionId, did);	1234
15		OH_GET_DOMAIN(did, d); /* Lock domain */	1235
15		OH_RESOURCE_GET(d, ResourceId, res);	1236
			1237
13		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_SENSOR)) {	1238
1		dbg("Resource %d in Domain %d doesn't have sensors",	1239
		ResourceId, did);	1240
1		oh_release_domain(d); /* Unlock domain */	1241
1		return SA_ERR_HPI_CAPABILITY;	1242
		}	1243
			1244
12		OH_HANDLER_GET(d, ResourceId, h);	1245
12		oh_release_domain(d); /* Unlock domain */	1246
			1247
12		get_func = h->abi->get_sensor_thresholds;	1248
			1249
12		if (!get_func) {	1250
0		return SA_ERR_HPI_INVALID_CMD;	1251
		}	1252
			1253
12		rv = get_func(h->hnd, ResourceId, SensorNum, SensorThresholds);	1254
			1255
12		return rv;	1256
		}	1257
			1258
		SaErrorT SAHPI_API saHpiSensorThresholdsSet (	1259
		SAHPI_IN SaHpiSessionIdT SessionId,	1260
		SAHPI_IN SaHpiResourceIdT ResourceId,	1261
		SAHPI_IN SaHpiSensorNumT SensorNum,	1262
		SAHPI_OUT SaHpiSensorThresholdsT *SensorThresholds)	1263
19		{	1264
19		SaErrorT rv;	1265
		SaErrorT (*set_func) (void *, SaHpiResourceIdT, SaHpiSensorNumT,	1266
19		const SaHpiSensorThresholdsT *);	1267
19		SaHpiRptEntryT *res;	1268
19		SaHpiRdrT *rdr;	1269
19		struct oh_handler *h;	1270
19		SaHpiDomainIdT did;	1271
19		struct oh_domain *d = NULL;	1272
			1273
19		if (!SensorThresholds) return SA_ERR_HPI_INVALID_DATA;	1274
			1275
17		OH_CHECK_INIT_STATE(SessionId);	1276
15		OH_GET_DID(SessionId, did);	1277
15		OH_GET_DOMAIN(did, d); /* Lock domain */	1278
15		OH_RESOURCE_GET(d, ResourceId, res);	1279
			1280
13		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_SENSOR)) {	1281
1		dbg("Resource %d in Domain %d doesn't have sensors",ResourceId,did);	1282
1		oh_release_domain(d); /* Unlock domain */	1283
1		return SA_ERR_HPI_CAPABILITY;	1284
		}	1285
			1286
12		rdr = oh_get_rdr_by_type(&(d->rpt), ResourceId, SAHPI_SENSOR_RDR, SensorNum);	1287
			1288
12		if (!rdr) {	1289
2		dbg("No Sensor %d found for ResourceId %d in Domain %d",	1290
		SensorNum, ResourceId, did);	1291
2		oh_release_domain(d);	1292
2		return SA_ERR_HPI_NOT_PRESENT;	1293
		}	1294
			1295
10		OH_HANDLER_GET(d, ResourceId, h);	1296
10		oh_release_domain(d); /* Unlock domain */	1297
			1298
10		set_func = h->abi->set_sensor_thresholds;	1299
10		if (!set_func) {	1300
0		return SA_ERR_HPI_INVALID_CMD;	1301
		}	1302
			1303
10		rv = set_func(h->hnd, ResourceId, SensorNum, SensorThresholds);	1304
			1305
10		return rv;	1306
		}	1307
			1308
		SaErrorT SAHPI_API saHpiSensorTypeGet (	1309
		SAHPI_IN SaHpiSessionIdT SessionId,	1310
		SAHPI_IN SaHpiResourceIdT ResourceId,	1311
		SAHPI_IN SaHpiSensorNumT SensorNum,	1312
		SAHPI_OUT SaHpiSensorTypeT *Type,	1313
		SAHPI_OUT SaHpiEventCategoryT *Category)	1314
15		{	1315
15		SaHpiRptEntryT *res;	1316
15		SaHpiRdrT *rdr;	1317
15		SaHpiDomainIdT did;	1318
15		struct oh_domain *d = NULL;	1319
			1320
15		if (!Type || !Category) return SA_ERR_HPI_INVALID_PARAMS;	1321
			1322
11		OH_CHECK_INIT_STATE(SessionId);	1323
9		OH_GET_DID(SessionId, did);	1324
9		OH_GET_DOMAIN(did, d); /* Lock domain */	1325
9		OH_RESOURCE_GET(d, ResourceId, res);	1326
			1327
7		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_SENSOR)) {	1328
1		dbg("Resource %d in Domain %d doesn't have sensors",	1329
		ResourceId, did);	1330
1		oh_release_domain(d); /* Unlock domain */	1331
1		return SA_ERR_HPI_CAPABILITY;	1332
		}	1333
			1334
6		rdr = oh_get_rdr_by_type(&(d->rpt), ResourceId, SAHPI_SENSOR_RDR, SensorNum);	1335
			1336
6		if (!rdr) {	1337
2		dbg("No Sensor num %d found for Resource %d in Domain %d",	1338
		SensorNum, ResourceId, did);	1339
2		oh_release_domain(d); /* Unlock domain */	1340
2		return SA_ERR_HPI_NOT_PRESENT;	1341
		}	1342
			1343
4		memcpy(Type,	1344
		&(rdr->RdrTypeUnion.SensorRec.Type),	1345
		sizeof(SaHpiSensorTypeT));	1346
			1347
4		memcpy(Category,	1348
		&(rdr->RdrTypeUnion.SensorRec.Category),	1349
		sizeof(SaHpiEventCategoryT));	1350
			1351
4		oh_release_domain(d); /* Unlock domain */	1352
			1353
4		return SA_OK;	1354
		}	1355
			1356
		SaErrorT SAHPI_API saHpiSensorEnableGet (	1357
		SAHPI_IN SaHpiSessionIdT SessionId,	1358
		SAHPI_IN SaHpiResourceIdT ResourceId,	1359
		SAHPI_IN SaHpiSensorNumT SensorNum,	1360
		SAHPI_OUT SaHpiBoolT *SensorEnabled)	1361
34		{	1362
34		SaErrorT rv;	1363
		SaErrorT (*get_sensor_enable)(void *hnd, SaHpiResourceIdT,	1364
		SaHpiSensorNumT,	1365
34		SaHpiBoolT *enable);	1366
			1367
34		SaHpiRptEntryT *res;	1368
34		struct oh_handler *h;	1369
34		SaHpiDomainIdT did;	1370
34		struct oh_domain *d = NULL;	1371
			1372
34		if (!SensorEnabled) return SA_ERR_HPI_INVALID_PARAMS;	1373
			1374
30		OH_CHECK_INIT_STATE(SessionId);	1375
28		OH_GET_DID(SessionId, did);	1376
28		OH_GET_DOMAIN(did, d); /* Lock domain */	1377
28		OH_RESOURCE_GET(d, ResourceId, res);	1378
			1379
26		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_SENSOR)) {	1380
1		dbg("Resource %d doesn't have sensors in Domain %d",	1381
		ResourceId, did);	1382
1		oh_release_domain(d); /* Unlock domain */	1383
1		return SA_ERR_HPI_CAPABILITY;	1384
		}	1385
			1386
25		OH_HANDLER_GET(d, ResourceId, h);	1387
25		oh_release_domain(d); /* Unlock domain */	1388
			1389
25		get_sensor_enable = h->abi->get_sensor_enable;	1390
25		if (!get_sensor_enable) {	1391
25		return SA_ERR_HPI_INVALID_CMD;	1392
		}	1393
			1394
0		rv = get_sensor_enable(h->hnd, ResourceId, SensorNum, SensorEnabled);	1395
0		return rv;	1396
		}	1397
			1398
		SaErrorT SAHPI_API saHpiSensorEnableSet (	1399
		SAHPI_IN SaHpiSessionIdT SessionId,	1400
		SAHPI_IN SaHpiResourceIdT ResourceId,	1401
		SAHPI_IN SaHpiSensorNumT SensorNum,	1402
		SAHPI_IN SaHpiBoolT SensorEnabled)	1403
2		{	1404
2		SaErrorT rv;	1405
		SaErrorT (*set_sensor_enable)(void *hnd, SaHpiResourceIdT,	1406
		SaHpiSensorNumT,	1407
2		SaHpiBoolT enable);	1408
2		SaHpiRptEntryT *res;	1409
2		struct oh_handler *h;	1410
2		SaHpiDomainIdT did;	1411
2		struct oh_domain *d = NULL;	1412
			1413
2		OH_CHECK_INIT_STATE(SessionId);	1414
2		OH_GET_DID(SessionId, did);	1415
2		OH_GET_DOMAIN(did, d); /* Lock domain */	1416
2		OH_RESOURCE_GET(d, ResourceId, res);	1417
			1418
2		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_SENSOR)) {	1419
1		dbg("Resource %d doesn't have sensors in Domain %d",	1420
		ResourceId, did);	1421
1		oh_release_domain(d); /* Unlock domain */	1422
1		return SA_ERR_HPI_CAPABILITY;	1423
		}	1424
			1425
1		OH_HANDLER_GET(d, ResourceId, h);	1426
1		oh_release_domain(d); /* Unlock domain */	1427
			1428
1		set_sensor_enable = h->abi->set_sensor_enable;	1429
1		if (!set_sensor_enable) {	1430
1		return SA_ERR_HPI_INVALID_CMD;	1431
		}	1432
			1433
0		rv = set_sensor_enable(h->hnd, ResourceId, SensorNum, SensorEnabled);	1434
			1435
0		return rv;	1436
		}	1437
			1438
		SaErrorT SAHPI_API saHpiSensorEventEnableGet (	1439
		SAHPI_IN SaHpiSessionIdT SessionId,	1440
		SAHPI_IN SaHpiResourceIdT ResourceId,	1441
		SAHPI_IN SaHpiSensorNumT SensorNum,	1442
		SAHPI_OUT SaHpiBoolT *SensorEventsEnabled)	1443
17		{	1444
17		SaErrorT rv;	1445
		SaErrorT (*get_sensor_event_enables)(void *hnd, SaHpiResourceIdT,	1446
		SaHpiSensorNumT,	1447
17		SaHpiBoolT *enables);	1448
			1449
17		SaHpiRptEntryT *res;	1450
17		struct oh_handler *h;	1451
17		SaHpiDomainIdT did;	1452
17		struct oh_domain *d = NULL;	1453
			1454
17		if (!SensorEventsEnabled) return SA_ERR_HPI_INVALID_PARAMS;	1455
			1456
13		OH_CHECK_INIT_STATE(SessionId);	1457
11		OH_GET_DID(SessionId, did);	1458
11		OH_GET_DOMAIN(did, d); /* Lock domain */	1459
11		OH_RESOURCE_GET(d, ResourceId, res);	1460
			1461
9		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_SENSOR)) {	1462
1		dbg("Resource %d doesn't have sensors in Domain %d",	1463
		ResourceId, did);	1464
1		oh_release_domain(d); /* Unlock domain */	1465
1		return SA_ERR_HPI_CAPABILITY;	1466
		}	1467
			1468
8		OH_HANDLER_GET(d, ResourceId, h);	1469
8		oh_release_domain(d); /* Unlock domain */	1470
			1471
8		get_sensor_event_enables = h->abi->get_sensor_event_enables;	1472
8		if (!get_sensor_event_enables) {	1473
0		return SA_ERR_HPI_INVALID_CMD;	1474
		}	1475
			1476
8		rv = get_sensor_event_enables(h->hnd, ResourceId, SensorNum, SensorEventsEnabled);	1477
			1478
8		return rv;	1479
		}	1480
			1481
		SaErrorT SAHPI_API saHpiSensorEventEnableSet (	1482
		SAHPI_IN SaHpiSessionIdT SessionId,	1483
		SAHPI_IN SaHpiResourceIdT ResourceId,	1484
		SAHPI_IN SaHpiSensorNumT SensorNum,	1485
		SAHPI_IN SaHpiBoolT SensorEventsEnabled)	1486
13		{	1487
13		SaErrorT rv;	1488
		SaErrorT (*set_sensor_event_enables)(void *hnd, SaHpiResourceIdT,	1489
		SaHpiSensorNumT,	1490
13		const SaHpiBoolT enables);	1491
13		SaHpiRptEntryT *res;	1492
13		struct oh_handler *h;	1493
13		SaHpiDomainIdT did;	1494
13		struct oh_domain *d = NULL;	1495
			1496
13		OH_CHECK_INIT_STATE(SessionId);	1497
11		OH_GET_DID(SessionId, did);	1498
11		OH_GET_DOMAIN(did, d); /* Lock domain */	1499
11		OH_RESOURCE_GET(d, ResourceId, res);	1500
			1501
9		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_SENSOR)) {	1502
1		dbg("Resource %d doesn't have sensors in Domain %d",	1503
		ResourceId, did);	1504
1		oh_release_domain(d); /* Unlock domain */	1505
1		return SA_ERR_HPI_CAPABILITY;	1506
		}	1507
			1508
8		OH_HANDLER_GET(d, ResourceId, h);	1509
8		oh_release_domain(d); /* Unlock domain */	1510
			1511
8		set_sensor_event_enables = h->abi->set_sensor_event_enables;	1512
8		if (!set_sensor_event_enables) {	1513
0		return SA_ERR_HPI_INVALID_CMD;	1514
		}	1515
			1516
8		rv = set_sensor_event_enables(h->hnd, ResourceId, SensorNum, SensorEventsEnabled);	1517
			1518
8		return rv;	1519
		}	1520
			1521
		SaErrorT SAHPI_API saHpiSensorEventMasksGet (	1522
		SAHPI_IN SaHpiSessionIdT SessionId,	1523
		SAHPI_IN SaHpiResourceIdT ResourceId,	1524
		SAHPI_IN SaHpiSensorNumT SensorNum,	1525
		SAHPI_INOUT SaHpiEventStateT *AssertEventMask,	1526
		SAHPI_INOUT SaHpiEventStateT *DeassertEventMask)	1527
7		{	1528
7		SaErrorT rv;	1529
		SaErrorT (*get_sensor_event_masks)(void *hnd, SaHpiResourceIdT,	1530
		SaHpiSensorNumT,	1531
		SaHpiEventStateT *AssertEventMask,	1532
7		SaHpiEventStateT *DeassertEventMask);	1533
7		SaHpiRptEntryT *res;	1534
7		struct oh_handler *h;	1535
7		SaHpiDomainIdT did;	1536
7		struct oh_domain *d = NULL;	1537
			1538
7		if (!AssertEventMask) return SA_ERR_HPI_INVALID_PARAMS;	1539
7		if (!DeassertEventMask) return SA_ERR_HPI_INVALID_PARAMS;	1540
			1541
			1542
7		OH_CHECK_INIT_STATE(SessionId);	1543
5		OH_GET_DID(SessionId, did);	1544
5		OH_GET_DOMAIN(did, d); /* Lock domain */	1545
5		OH_RESOURCE_GET(d, ResourceId, res);	1546
			1547
3		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_SENSOR)) {	1548
1		dbg("Resource %d doesn't have sensors in Domain %d",	1549
		ResourceId, did);	1550
1		oh_release_domain(d); /* Unlock domain */	1551
1		return SA_ERR_HPI_CAPABILITY;	1552
		}	1553
			1554
2		OH_HANDLER_GET(d, ResourceId, h);	1555
2		oh_release_domain(d); /* Unlock domain */	1556
			1557
2		get_sensor_event_masks = h->abi->get_sensor_event_masks;	1558
2		if (!get_sensor_event_masks) {	1559
2		return SA_ERR_HPI_INVALID_CMD;	1560
		}	1561
			1562
0		rv = get_sensor_event_masks(h->hnd, ResourceId, SensorNum,	1563
		AssertEventMask, DeassertEventMask);	1564
0		return rv;	1565
		}	1566
			1567
		SaErrorT SAHPI_API saHpiSensorEventMasksSet (	1568
		SAHPI_IN SaHpiSessionIdT SessionId,	1569
		SAHPI_IN SaHpiResourceIdT ResourceId,	1570
		SAHPI_IN SaHpiSensorNumT SensorNum,	1571
		SAHPI_IN SaHpiSensorEventMaskActionT Action,	1572
		SAHPI_IN SaHpiEventStateT AssertEventMask,	1573
		SAHPI_IN SaHpiEventStateT DeassertEventMask)	1574
8		{	1575
8		SaErrorT rv;	1576
		SaErrorT (*set_sensor_event_masks)(void *hnd, SaHpiResourceIdT,	1577
		SaHpiSensorNumT,	1578
		SaHpiSensorEventMaskActionT Action,	1579
		SaHpiEventStateT AssertEventMask,	1580
8		SaHpiEventStateT DeassertEventMask);	1581
8		SaHpiRptEntryT *res;	1582
8		struct oh_handler *h;	1583
8		SaHpiDomainIdT did;	1584
8		struct oh_domain *d = NULL;	1585
			1586
8		OH_CHECK_INIT_STATE(SessionId);	1587
6		OH_GET_DID(SessionId, did);	1588
6		OH_GET_DOMAIN(did, d); /* Lock domain */	1589
6		OH_RESOURCE_GET(d, ResourceId, res);	1590
			1591
4		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_SENSOR)) {	1592
2		dbg("Resource %d doesn't have sensors in Domain %d",	1593
		ResourceId, did);	1594
2		oh_release_domain(d); /* Unlock domain */	1595
2		return SA_ERR_HPI_CAPABILITY;	1596
		}	1597
			1598
2		OH_HANDLER_GET(d, ResourceId, h);	1599
2		oh_release_domain(d); /* Unlock domain */	1600
			1601
2		set_sensor_event_masks = h->abi->set_sensor_event_masks;	1602
2		if (!set_sensor_event_masks) {	1603
2		return SA_ERR_HPI_INVALID_CMD;	1604
		}	1605
			1606
0		rv = set_sensor_event_masks(h->hnd, ResourceId, SensorNum,	1607
		Action,	1608
		AssertEventMask,	1609
		DeassertEventMask);	1610
0		return rv;	1611
		}	1612
			1613
		/* End Sensor functions */	1614
			1615
		/*********************************************************************	1616
		*	1617
		* Control Functions	1618
		*	1619
		********************************************************************/	1620
			1621
		SaErrorT SAHPI_API saHpiControlTypeGet (	1622
		SAHPI_IN SaHpiSessionIdT SessionId,	1623
		SAHPI_IN SaHpiResourceIdT ResourceId,	1624
		SAHPI_IN SaHpiCtrlNumT CtrlNum,	1625
		SAHPI_OUT SaHpiCtrlTypeT *Type)	1626
6		{	1627
6		SaHpiRptEntryT *res;	1628
6		SaHpiRdrT *rdr;	1629
6		SaHpiDomainIdT did;	1630
6		struct oh_domain *d = NULL;	1631
			1632
6		if (!Type) return SA_ERR_HPI_INVALID_PARAMS;	1633
			1634
5		OH_CHECK_INIT_STATE(SessionId);	1635
4		OH_GET_DID(SessionId, did);	1636
4		OH_GET_DOMAIN(did, d); /* Lock domain */	1637
4		OH_RESOURCE_GET(d, ResourceId, res);	1638
			1639
3		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_CONTROL)) {	1640
1		dbg("Resource %d in Domain %d doesn't have controls",	1641
		ResourceId,did);	1642
1		oh_release_domain(d); /* Unlock domain */	1643
1		return SA_ERR_HPI_CAPABILITY;	1644
		}	1645
			1646
2		rdr = oh_get_rdr_by_type(&(d->rpt), ResourceId, SAHPI_CTRL_RDR, CtrlNum);	1647
2		if (!rdr) {	1648
0		oh_release_domain(d); /* Unlock domain */	1649
0		return SA_ERR_HPI_NOT_PRESENT;	1650
		}	1651
			1652
2		memcpy(Type,	1653
		&(rdr->RdrTypeUnion.CtrlRec.Type),	1654
		sizeof(SaHpiCtrlTypeT));	1655
			1656
2		oh_release_domain(d); /* Unlock domain */	1657
			1658
2		return SA_OK;	1659
		}	1660
			1661
		SaErrorT SAHPI_API saHpiControlGet (	1662
		SAHPI_IN SaHpiSessionIdT SessionId,	1663
		SAHPI_IN SaHpiResourceIdT ResourceId,	1664
		SAHPI_IN SaHpiCtrlNumT CtrlNum,	1665
		SAHPI_OUT SaHpiCtrlModeT *CtrlMode,	1666
		SAHPI_INOUT SaHpiCtrlStateT *CtrlState)	1667
6		{	1668
6		SaErrorT rv;	1669
		SaErrorT (*get_func)(void *, SaHpiResourceIdT, SaHpiCtrlNumT,	1670
6		SaHpiCtrlModeT *, SaHpiCtrlStateT *);	1671
6		SaHpiRptEntryT *res;	1672
6		struct oh_handler *h;	1673
6		SaHpiDomainIdT did;	1674
6		struct oh_domain *d = NULL;	1675
			1676
6		OH_CHECK_INIT_STATE(SessionId);	1677
5		OH_GET_DID(SessionId, did);	1678
5		OH_GET_DOMAIN(did, d); /* Lock domain */	1679
5		OH_RESOURCE_GET(d, ResourceId, res);	1680
			1681
4		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_CONTROL)) {	1682
2		dbg("Resource %d in Domain %d doesn't have controls",	1683
		ResourceId, d->id);	1684
2		oh_release_domain(d); /* Unlock domain */	1685
2		return SA_ERR_HPI_CAPABILITY;	1686
		}	1687
			1688
2		OH_HANDLER_GET(d, ResourceId, h);	1689
2		oh_release_domain(d); /* Unlock domain */	1690
			1691
2		get_func = h->abi->get_control_state;	1692
2		if (!get_func) {	1693
0		return SA_ERR_HPI_INVALID_CMD;	1694
		}	1695
			1696
2		rv = get_func(h->hnd, ResourceId, CtrlNum, CtrlMode, CtrlState);	1697
			1698
2		return rv;	1699
		}	1700
			1701
		SaErrorT SAHPI_API saHpiControlSet (	1702
		SAHPI_IN SaHpiSessionIdT SessionId,	1703
		SAHPI_IN SaHpiResourceIdT ResourceId,	1704
		SAHPI_IN SaHpiCtrlNumT CtrlNum,	1705
		SAHPI_IN SaHpiCtrlModeT CtrlMode,	1706
		SAHPI_IN SaHpiCtrlStateT *CtrlState)	1707
7		{	1708
7		SaErrorT rv;	1709
7		SaErrorT (*set_func)(void *, SaHpiResourceIdT, SaHpiCtrlNumT, SaHpiCtrlModeT, SaHpiCtrlStateT *);	1710
			1711
7		SaHpiRptEntryT *res;	1712
7		struct oh_handler *h;	1713
7		SaHpiDomainIdT did;	1714
7		struct oh_domain *d = NULL;	1715
			1716
7		if (!oh_lookup_ctrlmode(CtrlMode) ||	1717
		(CtrlMode != SAHPI_CTRL_MODE_AUTO && !CtrlState) ||	1718
		(CtrlState && CtrlState->Type == SAHPI_CTRL_TYPE_DIGITAL &&	1719
		!oh_lookup_ctrlstatedigital(CtrlState->StateUnion.Digital)) ||	1720
		(CtrlState && CtrlState->Type == SAHPI_CTRL_TYPE_STREAM &&	1721
		CtrlState->StateUnion.Stream.StreamLength > SAHPI_CTRL_MAX_STREAM_LENGTH))	1722
		{	1723
1		return SA_ERR_HPI_INVALID_PARAMS;	1724
		}	1725
			1726
6		OH_CHECK_INIT_STATE(SessionId);	1727
5		OH_GET_DID(SessionId, did);	1728
5		OH_GET_DOMAIN(did, d); /* Lock domain */	1729
5		OH_RESOURCE_GET(d, ResourceId, res);	1730
			1731
4		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_CONTROL)) {	1732
3		dbg("Resource %d in Domain %d doesn't have controls",	1733
		ResourceId, did);	1734
3		oh_release_domain(d); /* Unlock domain */	1735
3		return SA_ERR_HPI_CAPABILITY;	1736
		}	1737
			1738
1		OH_HANDLER_GET(d, ResourceId, h);	1739
1		oh_release_domain(d); /* Unlock domain */	1740
			1741
1		set_func = h->abi->set_control_state;	1742
1		if (!set_func) {	1743
0		return SA_ERR_HPI_INVALID_CMD;	1744
		}	1745
			1746
1		rv = set_func(h->hnd, ResourceId, CtrlNum, CtrlMode, CtrlState);	1747
			1748
1		return rv;	1749
		}	1750
			1751
			1752
		/*********************************************************************	1753
		*	1754
		* Inventory Functions	1755
		*	1756
		********************************************************************/	1757
			1758
		SaErrorT SAHPI_API saHpiIdrInfoGet(	1759
		SAHPI_IN SaHpiSessionIdT SessionId,	1760
		SAHPI_IN SaHpiResourceIdT ResourceId,	1761
		SAHPI_IN SaHpiIdrIdT IdrId,	1762
		SAHPI_OUT SaHpiIdrInfoT *IdrInfo)	1763
114		{	1764
			1765
114		SaHpiRptEntryT *res;	1766
114		SaErrorT rv = SA_OK; /* Default to SA_OK */	1767
114		SaHpiDomainIdT did;	1768
114		struct oh_domain *d = NULL;	1769
114		struct oh_handler *h;	1770
114		SaErrorT (*set_func)(void *, SaHpiResourceIdT, SaHpiIdrIdT, SaHpiIdrInfoT *);	1771
			1772
114		if (IdrInfo == NULL) {	1773
1		dbg("NULL IdrInfo");	1774
1		rv = SA_ERR_HPI_INVALID_PARAMS;	1775
		}	1776
			1777
114		OH_CHECK_INIT_STATE(SessionId);	1778
113		OH_GET_DID(SessionId, did);	1779
113		OH_GET_DOMAIN(did, d); /* Lock domain */	1780
113		OH_RESOURCE_GET(d, ResourceId, res);	1781
			1782
		/* Interface and conformance checking */	1783
112		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_INVENTORY_DATA)) {	1784
1		dbg("Resource %d in Domain %d doesn't have inventory data",	1785
		ResourceId,did);	1786
1		oh_release_domain(d); /* Unlock domain */	1787
1		return SA_ERR_HPI_CAPABILITY;	1788
		}	1789
			1790
111		OH_HANDLER_GET(d, ResourceId, h);	1791
111		oh_release_domain(d); /* Unlock domain */	1792
			1793
111		set_func = h->abi->get_idr_info;	1794
111		if (!set_func) {	1795
0		dbg("Plugin does not have this function in jump table.");	1796
0		return SA_ERR_HPI_INVALID_CMD;	1797
		}	1798
			1799
		/* Access Inventory Info from plugin */	1800
111		trace("Access IdrInfo from plugin.");	1801
111		rv = set_func(h->hnd, ResourceId, IdrId, IdrInfo);	1802
			1803
111		return rv;	1804
		}	1805
			1806
		SaErrorT SAHPI_API saHpiIdrAreaHeaderGet(	1807
		SAHPI_IN SaHpiSessionIdT SessionId,	1808
		SAHPI_IN SaHpiResourceIdT ResourceId,	1809
		SAHPI_IN SaHpiIdrIdT IdrId,	1810
		SAHPI_IN SaHpiIdrAreaTypeT AreaType,	1811
		SAHPI_IN SaHpiEntryIdT AreaId,	1812
		SAHPI_OUT SaHpiEntryIdT *NextAreaId,	1813
		SAHPI_OUT SaHpiIdrAreaHeaderT *Header)	1814
44		{	1815
			1816
44		SaHpiRptEntryT *res;	1817
44		SaErrorT rv = SA_OK; /* Default to SA_OK */	1818
44		SaHpiDomainIdT did;	1819
44		struct oh_domain *d = NULL;	1820
44		struct oh_handler *h;	1821
		SaErrorT (*set_func)(void *, SaHpiResourceIdT, SaHpiIdrIdT, SaHpiIdrAreaTypeT,	1822
44		SaHpiEntryIdT, SaHpiEntryIdT *, SaHpiIdrAreaHeaderT *);	1823
			1824
44		if ( ((AreaType < SAHPI_IDR_AREATYPE_INTERNAL_USE) ||	1825
		((AreaType > SAHPI_IDR_AREATYPE_PRODUCT_INFO) &&	1826
		(AreaType != SAHPI_IDR_AREATYPE_UNSPECIFIED) &&	1827
		(AreaType != SAHPI_IDR_AREATYPE_OEM)) ||	1828
		(AreaId == SAHPI_LAST_ENTRY)||	1829
		(NextAreaId == NULL) ||	1830
		(Header == NULL))) {	1831
4		dbg("Invalid Parameters");	1832
4		return SA_ERR_HPI_INVALID_PARAMS;	1833
		}	1834
			1835
40		OH_CHECK_INIT_STATE(SessionId);	1836
39		OH_GET_DID(SessionId, did);	1837
39		OH_GET_DOMAIN(did, d); /* Lock domain */	1838
39		OH_RESOURCE_GET(d, ResourceId, res);	1839
			1840
		/* Interface and conformance checking */	1841
38		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_INVENTORY_DATA)) {	1842
0		dbg("Resource %d in Domain %d doesn't have inventory data",	1843
		ResourceId,did);	1844
0		oh_release_domain(d); /* Unlock domain */	1845
0		return SA_ERR_HPI_CAPABILITY;	1846
		}	1847
			1848
38		OH_HANDLER_GET(d, ResourceId, h);	1849
38		oh_release_domain(d); /* Unlock domain */	1850
			1851
38		set_func = h->abi->get_idr_area_header;	1852
38		if (!set_func) {	1853
0		dbg("Plugin does not have this function in jump table.");	1854
0		return SA_ERR_HPI_INVALID_CMD;	1855
		}	1856
			1857
			1858
		/* Access Inventory Info from plugin */	1859
38		trace("Access IdrAreaHeader from plugin.");	1860
38		rv = set_func(h->hnd, ResourceId, IdrId, AreaType, AreaId, NextAreaId, Header);	1861
			1862
38		return rv;	1863
		}	1864
			1865
		SaErrorT SAHPI_API saHpiIdrAreaAdd(	1866
		SAHPI_IN SaHpiSessionIdT SessionId,	1867
		SAHPI_IN SaHpiResourceIdT ResourceId,	1868
		SAHPI_IN SaHpiIdrIdT IdrId,	1869
		SAHPI_IN SaHpiIdrAreaTypeT AreaType,	1870
		SAHPI_OUT SaHpiEntryIdT *AreaId)	1871
2		{	1872
2		SaHpiRptEntryT *res;	1873
2		SaErrorT rv = SA_OK; /* Default to SA_OK */	1874
2		SaHpiDomainIdT did;	1875
2		struct oh_domain *d = NULL;	1876
2		struct oh_handler *h;	1877
		SaErrorT (*set_func)(void *, SaHpiResourceIdT, SaHpiIdrIdT, SaHpiIdrAreaTypeT,	1878
2		SaHpiEntryIdT *);	1879
			1880
2		if ( ((AreaType < SAHPI_IDR_AREATYPE_INTERNAL_USE) ||	1881
		((AreaType > SAHPI_IDR_AREATYPE_PRODUCT_INFO) &&	1882
		(AreaType != SAHPI_IDR_AREATYPE_UNSPECIFIED) &&	1883
		(AreaType != SAHPI_IDR_AREATYPE_OEM)) ||	1884
		(AreaId == NULL))) {	1885
0		dbg("Invalid Parameters");	1886
0		return SA_ERR_HPI_INVALID_PARAMS;	1887
		}	1888
			1889
2		OH_CHECK_INIT_STATE(SessionId);	1890
2		OH_GET_DID(SessionId, did);	1891
2		OH_GET_DOMAIN(did, d); /* Lock domain */	1892
2		OH_RESOURCE_GET(d, ResourceId, res);	1893
			1894
		/* Interface and conformance checking */	1895
2		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_INVENTORY_DATA)) {	1896
1		dbg("Resource %d in Domain %d doesn't have inventory data",	1897
		ResourceId,did);	1898
1		oh_release_domain(d); /* Unlock domain */	1899
1		return SA_ERR_HPI_CAPABILITY;	1900
		}	1901
			1902
1		OH_HANDLER_GET(d, ResourceId, h);	1903
1		oh_release_domain(d); /* Unlock domain */	1904
			1905
1		set_func = h->abi->add_idr_area;	1906
1		if (!set_func) {	1907
0		dbg("Plugin does not have this function in jump table.");	1908
0		return SA_ERR_HPI_INVALID_CMD;	1909
		}	1910
			1911
		/* Access Inventory Info from plugin */	1912
1		trace("Access IdrAreaAdd from plugin.");	1913
1		rv = set_func(h->hnd, ResourceId, IdrId, AreaType, AreaId);	1914
			1915
1		return rv;	1916
		}	1917
			1918
		SaErrorT SAHPI_API saHpiIdrAreaDelete(	1919
		SAHPI_IN SaHpiSessionIdT SessionId,	1920
		SAHPI_IN SaHpiResourceIdT ResourceId,	1921
		SAHPI_IN SaHpiIdrIdT IdrId,	1922
		SAHPI_IN SaHpiEntryIdT AreaId)	1923
1		{	1924
1		SaHpiRptEntryT *res;	1925
1		SaErrorT rv = SA_OK; /* Default to SA_OK */	1926
1		SaHpiDomainIdT did;	1927
1		struct oh_domain *d = NULL;	1928
1		struct oh_handler *h;	1929
1		SaErrorT (*set_func)(void *, SaHpiResourceIdT, SaHpiIdrIdT, SaHpiEntryIdT );	1930
			1931
1		if (AreaId == SAHPI_LAST_ENTRY) {	1932
0		dbg("Invalid Parameters");	1933
0		return SA_ERR_HPI_INVALID_PARAMS;	1934
		}	1935
			1936
1		OH_CHECK_INIT_STATE(SessionId);	1937
1		OH_GET_DID(SessionId, did);	1938
1		OH_GET_DOMAIN(did, d); /* Lock domain */	1939
1		OH_RESOURCE_GET(d, ResourceId, res);	1940
			1941
		/* Interface and conformance checking */	1942
1		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_INVENTORY_DATA)) {	1943
1		dbg("Resource %d in Domain %d doesn't have inventory data",	1944
		ResourceId,did);	1945
1		oh_release_domain(d); /* Unlock domain */	1946
1		return SA_ERR_HPI_CAPABILITY;	1947
		}	1948
			1949
0		OH_HANDLER_GET(d, ResourceId, h);	1950
0		oh_release_domain(d); /* Unlock domain */	1951
			1952
0		set_func = h->abi->del_idr_area;	1953
0		if (!set_func) {	1954
0		dbg("Plugin does not have this function in jump table.");	1955
0		return SA_ERR_HPI_INVALID_CMD;	1956
		}	1957
			1958
		/* Access Inventory Info from plugin */	1959
0		trace("Access IdrAreaDelete from plugin.");	1960
0		rv = set_func(h->hnd, ResourceId, IdrId, AreaId);	1961
			1962
0		return rv;	1963
		}	1964
			1965
		SaErrorT SAHPI_API saHpiIdrFieldGet(	1966
		SAHPI_IN SaHpiSessionIdT SessionId,	1967
		SAHPI_IN SaHpiResourceIdT ResourceId,	1968
		SAHPI_IN SaHpiIdrIdT IdrId,	1969
		SAHPI_IN SaHpiEntryIdT AreaId,	1970
		SAHPI_IN SaHpiIdrFieldTypeT FieldType,	1971
		SAHPI_IN SaHpiEntryIdT FieldId,	1972
		SAHPI_OUT SaHpiEntryIdT *NextFieldId,	1973
		SAHPI_OUT SaHpiIdrFieldT *Field)	1974
62		{	1975
62		SaHpiRptEntryT *res;	1976
62		SaErrorT rv = SA_OK; /* Default to SA_OK */	1977
62		SaHpiDomainIdT did;	1978
62		struct oh_domain *d = NULL;	1979
62		struct oh_handler *h;	1980
		SaErrorT (*set_func)(void *, SaHpiResourceIdT, SaHpiIdrIdT,	1981
		SaHpiEntryIdT, SaHpiIdrFieldTypeT, SaHpiEntryIdT,	1982
62		SaHpiEntryIdT *, SaHpiIdrFieldT * );	1983
			1984
62		if ((((FieldType > SAHPI_IDR_FIELDTYPE_CUSTOM) &&	1985
		(FieldType != SAHPI_IDR_FIELDTYPE_UNSPECIFIED)) ||	1986
		(AreaId == SAHPI_LAST_ENTRY) ||	1987
		(FieldId == SAHPI_LAST_ENTRY) ||	1988
		(NextFieldId == NULL) ||	1989
		(Field == NULL))) {	1990
10		dbg("Invalid Parameters");	1991
10		return SA_ERR_HPI_INVALID_PARAMS;	1992
		}	1993
			1994
52		OH_CHECK_INIT_STATE(SessionId);	1995
50		OH_GET_DID(SessionId, did);	1996
50		OH_GET_DOMAIN(did, d); /* Lock domain */	1997
50		OH_RESOURCE_GET(d, ResourceId, res);	1998
			1999
		/* Interface and conformance checking */	2000
48		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_INVENTORY_DATA)) {	2001
0		dbg("Resource %d in Domain %d doesn't have inventory data",	2002
		ResourceId,did);	2003
0		oh_release_domain(d); /* Unlock domain */	2004
0		return SA_ERR_HPI_CAPABILITY;	2005
		}	2006
			2007
48		OH_HANDLER_GET(d, ResourceId, h);	2008
48		oh_release_domain(d); /* Unlock domain */	2009
			2010
48		set_func = h->abi->get_idr_field;	2011
48		if (!set_func) {	2012
0		dbg("Plugin does not have this function in jump table.");	2013
0		return SA_ERR_HPI_INVALID_CMD;	2014
		}	2015
			2016
			2017
		/* Access Inventory Info from plugin */	2018
48		trace("Access saHpiIdrFieldGet from plugin.");	2019
48		rv = set_func(h->hnd, ResourceId, IdrId, AreaId,	2020
		FieldType, FieldId, NextFieldId, Field);	2021
			2022
48		return rv;	2023
		}	2024
			2025
		SaErrorT SAHPI_API saHpiIdrFieldAdd(	2026
		SAHPI_IN SaHpiSessionIdT SessionId,	2027
		SAHPI_IN SaHpiResourceIdT ResourceId,	2028
		SAHPI_IN SaHpiIdrIdT IdrId,	2029
		SAHPI_INOUT SaHpiIdrFieldT *Field)	2030
6		{	2031
6		SaHpiRptEntryT *res;	2032
6		SaErrorT rv = SA_OK; /* Default to SA_OK */	2033
6		SaHpiDomainIdT did;	2034
6		struct oh_domain *d = NULL;	2035
6		struct oh_handler *h;	2036
6		SaErrorT (*set_func)(void *, SaHpiResourceIdT, SaHpiIdrIdT, SaHpiIdrFieldT * );	2037
			2038
6		if (!Field) {	2039
0		dbg("Invalid Parameter: Field is NULL ");	2040
0		return SA_ERR_HPI_INVALID_PARAMS;	2041
6		} else if (Field->Type > SAHPI_IDR_FIELDTYPE_CUSTOM) {	2042
0		dbg("Invalid Parameters in Field->Type");	2043
0		return SA_ERR_HPI_INVALID_PARAMS;	2044
		}	2045
			2046
6		OH_CHECK_INIT_STATE(SessionId);	2047
6		OH_GET_DID(SessionId, did);	2048
6		OH_GET_DOMAIN(did, d); /* Lock domain */	2049
6		OH_RESOURCE_GET(d, ResourceId, res);	2050
			2051
		/* Interface and conformance checking */	2052
6		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_INVENTORY_DATA)) {	2053
2		dbg("Resource %d in Domain %d doesn't have inventory data",	2054
		ResourceId,did);	2055
2		oh_release_domain(d); /* Unlock domain */	2056
2		return SA_ERR_HPI_CAPABILITY;	2057
		}	2058
			2059
4		OH_HANDLER_GET(d, ResourceId, h);	2060
4		oh_release_domain(d); /* Unlock domain */	2061
			2062
4		set_func = h->abi->add_idr_field;	2063
4		if (!set_func) {	2064
0		dbg("Plugin does not have this function in jump table.");	2065
0		return SA_ERR_HPI_INVALID_CMD;	2066
		}	2067
			2068
		/* Access Inventory Info from plugin */	2069
4		trace("Access saHpiIdrFieldAdd from plugin.");	2070
4		rv = set_func(h->hnd, ResourceId, IdrId, Field);	2071
			2072
4		return rv;	2073
		}	2074
			2075
		SaErrorT SAHPI_API saHpiIdrFieldSet(	2076
		SAHPI_IN SaHpiSessionIdT SessionId,	2077
		SAHPI_IN SaHpiResourceIdT ResourceId,	2078
		SAHPI_IN SaHpiIdrIdT IdrId,	2079
		SAHPI_IN SaHpiIdrFieldT *Field)	2080
3		{	2081
3		SaHpiRptEntryT *res;	2082
3		SaErrorT rv = SA_OK; /* Default to SA_OK */	2083
3		SaHpiDomainIdT did;	2084
3		struct oh_domain *d = NULL;	2085
3		struct oh_handler *h;	2086
3		SaErrorT (*set_func)(void *, SaHpiResourceIdT, SaHpiIdrIdT, SaHpiIdrFieldT * );	2087
			2088
3		if (!Field) {	2089
0		dbg("Invalid Parameter: Field is NULL ");	2090
0		return SA_ERR_HPI_INVALID_PARAMS;	2091
3		} else if (Field->Type > SAHPI_IDR_FIELDTYPE_CUSTOM) {	2092
0		dbg("Invalid Parameters in Field->Type");	2093
0		return SA_ERR_HPI_INVALID_PARAMS;	2094
		}	2095
			2096
3		OH_CHECK_INIT_STATE(SessionId);	2097
3		OH_GET_DID(SessionId, did);	2098
3		OH_GET_DOMAIN(did, d); /* Lock domain */	2099
3		OH_RESOURCE_GET(d, ResourceId, res);	2100
			2101
		/* Interface and conformance checking */	2102
3		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_INVENTORY_DATA)) {	2103
2		dbg("Resource %d in Domain %d doesn't have inventory data",	2104
		ResourceId,did);	2105
2		oh_release_domain(d); /* Unlock domain */	2106
2		return SA_ERR_HPI_CAPABILITY;	2107
		}	2108
			2109
1		OH_HANDLER_GET(d, ResourceId, h);	2110
1		oh_release_domain(d); /* Unlock domain */	2111
			2112
1		set_func = h->abi->set_idr_field;	2113
1		if (!set_func) {	2114
0		dbg("Plugin does not have this function in jump table.");	2115
0		return SA_ERR_HPI_INVALID_CMD;	2116
		}	2117
			2118
		/* Access Inventory Info from plugin */	2119
1		trace("Access saHpiIdrFieldSet from plugin.");	2120
1		rv = set_func(h->hnd, ResourceId, IdrId, Field);	2121
			2122
1		return rv;	2123
		}	2124
			2125
		SaErrorT SAHPI_API saHpiIdrFieldDelete(	2126
		SAHPI_IN SaHpiSessionIdT SessionId,	2127
		SAHPI_IN SaHpiResourceIdT ResourceId,	2128
		SAHPI_IN SaHpiIdrIdT IdrId,	2129
		SAHPI_IN SaHpiEntryIdT AreaId,	2130
		SAHPI_IN SaHpiEntryIdT FieldId)	2131
3		{	2132
3		SaHpiRptEntryT *res;	2133
3		SaErrorT rv = SA_OK; /* Default to SA_OK */	2134
3		SaHpiDomainIdT did;	2135
3		struct oh_handler *h;	2136
3		struct oh_domain *d = NULL;	2137
3		SaErrorT (*set_func)(void *, SaHpiResourceIdT, SaHpiIdrIdT, SaHpiEntryIdT, SaHpiEntryIdT );	2138
			2139
3		if (FieldId == SAHPI_LAST_ENTRY || AreaId == SAHPI_LAST_ENTRY) {	2140
0		dbg("Invalid Parameters");	2141
0		return SA_ERR_HPI_INVALID_PARAMS;	2142
		}	2143
			2144
3		OH_CHECK_INIT_STATE(SessionId);	2145
3		OH_GET_DID(SessionId, did);	2146
3		OH_GET_DOMAIN(did, d); /* Lock domain */	2147
3		OH_RESOURCE_GET(d, ResourceId, res);	2148
			2149
		/* Interface and conformance checking */	2150
3		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_INVENTORY_DATA)) {	2151
2		dbg("Resource %d in Domain %d doesn't have inventory data",	2152
		ResourceId,did);	2153
2		oh_release_domain(d); /* Unlock domain */	2154
2		return SA_ERR_HPI_CAPABILITY;	2155
		}	2156
			2157
1		OH_HANDLER_GET(d, ResourceId, h);	2158
1		oh_release_domain(d); /* Unlock domain */	2159
			2160
1		set_func = h->abi->del_idr_field;	2161
1		if (!set_func) {	2162
0		dbg("Plugin does not have this function in jump table.");	2163
0		return SA_ERR_HPI_INVALID_CMD;	2164
		}	2165
			2166
		/* Access Inventory Info from plugin */	2167
1		trace("Access saHpiIdrFieldDelete from plugin.");	2168
1		rv = set_func(h->hnd, ResourceId, IdrId, AreaId, FieldId);	2169
			2170
1		return rv;	2171
		}	2172
			2173
		/* End of Inventory Functions */	2174
			2175
		/*********************************************************************	2176
		*	2177
		* Watchdog Functions	2178
		*	2179
		********************************************************************/	2180
			2181
		SaErrorT SAHPI_API saHpiWatchdogTimerGet (	2182
		SAHPI_IN SaHpiSessionIdT SessionId,	2183
		SAHPI_IN SaHpiResourceIdT ResourceId,	2184
		SAHPI_IN SaHpiWatchdogNumT WatchdogNum,	2185
		SAHPI_OUT SaHpiWatchdogT *Watchdog)	2186
0		{	2187
0		SaErrorT rv;	2188
0		SaErrorT (*get_func)(void *, SaHpiResourceIdT, SaHpiWatchdogNumT, SaHpiWatchdogT *);	2189
0		SaHpiRptEntryT *res;	2190
0		struct oh_handler *h;	2191
0		struct oh_domain *d = NULL;	2192
0		SaHpiDomainIdT did;	2193
			2194
0		if (!Watchdog) return SA_ERR_HPI_INVALID_PARAMS;	2195
			2196
0		OH_CHECK_INIT_STATE(SessionId);	2197
0		OH_GET_DID(SessionId, did);	2198
0		OH_GET_DOMAIN(did, d); /* Lock domain */	2199
0		OH_RESOURCE_GET(d, ResourceId, res);	2200
			2201
0		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_WATCHDOG)) {	2202
0		dbg("Resource %d in Domain %d doesn't have watchdog",	2203
		ResourceId,did);	2204
0		oh_release_domain(d); /* Unlock domain */	2205
0		return SA_ERR_HPI_CAPABILITY;	2206
		}	2207
			2208
0		OH_HANDLER_GET(d, ResourceId, h);	2209
0		oh_release_domain(d); /* Unlock domain */	2210
			2211
0		get_func = h->abi->get_watchdog_info;	2212
0		if (!get_func) {	2213
0		return SA_ERR_HPI_INVALID_CMD;	2214
		}	2215
			2216
0		rv = get_func(h->hnd, ResourceId, WatchdogNum, Watchdog);	2217
			2218
0		return rv;	2219
		}	2220
			2221
		SaErrorT SAHPI_API saHpiWatchdogTimerSet (	2222
		SAHPI_IN SaHpiSessionIdT SessionId,	2223
		SAHPI_IN SaHpiResourceIdT ResourceId,	2224
		SAHPI_IN SaHpiWatchdogNumT WatchdogNum,	2225
		SAHPI_IN SaHpiWatchdogT *Watchdog)	2226
0		{	2227
0		SaErrorT rv;	2228
0		SaErrorT (*set_func)(void *, SaHpiResourceIdT, SaHpiWatchdogNumT, SaHpiWatchdogT *);	2229
0		SaHpiRptEntryT *res;	2230
0		struct oh_handler *h;	2231
0		struct oh_domain *d = NULL;	2232
0		SaHpiDomainIdT did;	2233
			2234
0		if (!Watchdog ||	2235
		(Watchdog && (!oh_lookup_watchdogtimeruse(Watchdog->TimerUse) ||	2236
		!oh_lookup_watchdogaction(Watchdog->TimerAction) ||	2237
		!oh_lookup_watchdogpretimerinterrupt(Watchdog->PretimerInterrupt)))) {	2238
0		return SA_ERR_HPI_INVALID_PARAMS;	2239
		}	2240
			2241
0		OH_CHECK_INIT_STATE(SessionId);	2242
0		OH_GET_DID(SessionId, did);	2243
0		OH_GET_DOMAIN(did, d); /* Lock domain */	2244
0		OH_RESOURCE_GET(d, ResourceId, res);	2245
			2246
0		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_WATCHDOG)) {	2247
0		dbg("Resource %d in Domain %d doesn't have watchdog",	2248
		ResourceId,did);	2249
0		oh_release_domain(d); /* Unlock domain */	2250
0		return SA_ERR_HPI_CAPABILITY;	2251
		}	2252
			2253
0		OH_HANDLER_GET(d, ResourceId, h);	2254
0		oh_release_domain(d); /* Unlock domain */	2255
			2256
0		set_func = h->abi->set_watchdog_info;	2257
0		if (!set_func) {	2258
0		return SA_ERR_HPI_INVALID_CMD;	2259
		}	2260
			2261
0		rv = set_func(h->hnd, ResourceId, WatchdogNum, Watchdog);	2262
			2263
0		return rv;	2264
		}	2265
			2266
		SaErrorT SAHPI_API saHpiWatchdogTimerReset (	2267
		SAHPI_IN SaHpiSessionIdT SessionId,	2268
		SAHPI_IN SaHpiResourceIdT ResourceId,	2269
		SAHPI_IN SaHpiWatchdogNumT WatchdogNum)	2270
0		{	2271
0		SaErrorT rv;	2272
0		SaErrorT (*reset_func)(void *, SaHpiResourceIdT, SaHpiWatchdogNumT);	2273
0		SaHpiRptEntryT *res;	2274
0		struct oh_handler *h;	2275
0		struct oh_domain *d = NULL;	2276
0		SaHpiDomainIdT did;	2277
			2278
0		OH_CHECK_INIT_STATE(SessionId);	2279
0		OH_GET_DID(SessionId, did);	2280
0		OH_GET_DOMAIN(did, d); /* Lock domain */	2281
0		OH_RESOURCE_GET(d, ResourceId, res);	2282
			2283
0		if(!(res->ResourceCapabilities & SAHPI_CAPABILITY_WATCHDOG)) {	2284
0		dbg("Resource %d in Domain %d doesn't have watchdog",	2285
		ResourceId,did);	2286
0		oh_release_domain(d); /* Unlock domain */	2287
0		return SA_ERR_HPI_CAPABILITY;	2288
		}	2289
			2290
0		OH_HANDLER_GET(d, ResourceId, h);	2291
0		oh_release_domain(d); /* Unlock domain */	2292
			2293
0		reset_func = h->abi->reset_watchdog;	2294
0		if (!reset_func) {	2295
0		return SA_ERR_HPI_INVALID_CMD;	2296
		}	2297
			2298
0		rv = reset_func(h->hnd, ResourceId, WatchdogNum);	2299
			2300
0		return rv;	2301
		}	2302
			2303
		/*******************************************************************************	2304
		*	2305
		* Annunciator Functions	2306
		*	2307
		******************************************************************************/	2308
			2309
		SaErrorT SAHPI_API saHpiAnnunciatorGetNext(	2310
		SAHPI_IN SaHpiSessionIdT SessionId,	2311
		SAHPI_IN SaHpiResourceIdT ResourceId,	2312
		SAHPI_IN SaHpiAnnunciatorNumT AnnunciatorNum,	2313
		SAHPI_IN SaHpiSeverityT Severity,	2314
		SAHPI_IN SaHpiBoolT UnacknowledgedOnly,	2315
		SAHPI_INOUT SaHpiAnnouncementT *Announcement)	2316
0		{	2317
0		return SA_ERR_HPI_UNSUPPORTED_API;	2318
		}	2319
			2320
		SaErrorT SAHPI_API saHpiAnnunciatorGet(	2321
		SAHPI_IN SaHpiSessionIdT SessionId,	2322
		SAHPI_IN SaHpiResourceIdT ResourceId,	2323
		SAHPI_IN SaHpiAnnunciatorNumT AnnunciatorNum,	2324
		SAHPI_IN SaHpiEntryIdT EntryId,	2325
		SAHPI_OUT SaHpiAnnouncementT *Announcement)	2326
0		{	2327
0		return SA_ERR_HPI_UNSUPPORTED_API;	2328
		}	2329
			2330
		SaErrorT SAHPI_API saHpiAnnunciatorAcknowledge(	2331
		SAHPI_IN SaHpiSessionIdT SessionId,	2332
		SAHPI_IN SaHpiResourceIdT ResourceId,	2333
		SAHPI_IN SaHpiAnnunciatorNumT AnnunciatorNum,	2334
		SAHPI_IN SaHpiEntryIdT EntryId,	2335
		SAHPI_IN SaHpiSeverityT Severity)	2336
0		{	2337
0		return SA_ERR_HPI_UNSUPPORTED_API;	2338
		}	2339
			2340
		SaErrorT SAHPI_API saHpiAnnunciatorAdd(	2341
		SAHPI_IN SaHpiSessionIdT SessionId,	2342
		SAHPI_IN SaHpiResourceIdT ResourceId,	2343
		SAHPI_IN SaHpiAnnunciatorNumT AnnunciatorNum,	2344
		SAHPI_INOUT SaHpiAnnouncementT *Announcement)	2345
0		{	2346
0		return SA_ERR_HPI_UNSUPPORTED_API;	2347
		}	2348
			2349
		SaErrorT SAHPI_API saHpiAnnunciatorDelete(	2350
		SAHPI_IN SaHpiSessionIdT SessionId,	2351
		SAHPI_IN SaHpiResourceIdT ResourceId,	2352
		SAHPI_IN SaHpiAnnunciatorNumT AnnunciatorNum,	2353
		SAHPI_IN SaHpiEntryIdT EntryId,	2354
		SAHPI_IN SaHpiSeverityT Severity)	2355
0		{	2356
0		return SA_ERR_HPI_UNSUPPORTED_API;	2357
		}	2358
			2359
		SaErrorT SAHPI_API saHpiAnnunciatorModeGet(	2360
		SAHPI_IN SaHpiSessionIdT SessionId,	2361
		SAHPI_IN SaHpiResourceIdT ResourceId,	2362
		SAHPI_IN SaHpiAnnunciatorNumT AnnunciatorNum,	2363
		SAHPI_OUT SaHpiAnnunciatorModeT *Mode)	2364
0		{	2365
0		return SA_ERR_HPI_UNSUPPORTED_API;	2366
		}	2367
			2368
		SaErrorT SAHPI_API saHpiAnnunciatorModeSet(	2369
		SAHPI_IN SaHpiSessionIdT SessionId,	2370
		SAHPI_IN SaHpiResourceIdT ResourceId,	2371
		SAHPI_IN SaHpiAnnunciatorNumT AnnunciatorNum,	2372
		SAHPI_IN SaHpiAnnunciatorModeT Mode)	2373
0		{	2374
0		return SA_ERR_HPI_UNSUPPORTED_API;	2375
		}	2376
			2377
		/*******************************************************************************	2378
		*	2379
		* Hotswap Functions	2380
		*	2381
		******************************************************************************/	2382
			2383
		SaErrorT SAHPI_API saHpiHotSwapPolicyCancel (	2384
		SAHPI_IN SaHpiSessionIdT SessionId,	2385
		SAHPI_IN SaHpiResourceIdT ResourceId)	2386
0		{	2387
0		return SA_ERR_HPI_UNSUPPORTED_API;	2388
		}	2389
			2390
		SaErrorT SAHPI_API saHpiResourceActiveSet (	2391
		SAHPI_IN SaHpiSessionIdT SessionId,	2392
		SAHPI_IN SaHpiResourceIdT ResourceId)	2393
3		{	2394
3		SaErrorT rv;	2395
		SaErrorT (*set_hotswap_state)(void *hnd, SaHpiResourceIdT,	2396
3		SaHpiHsStateT state);	2397
			2398
3		SaHpiRptEntryT *res;	2399
3		struct oh_handler *h;	2400
3		SaHpiDomainIdT did;	2401
3		struct oh_domain *d = NULL;	2402
3		struct oh_resource_data *rd;	2403
			2404
3		OH_CHECK_INIT_STATE(SessionId);	2405
2		OH_GET_DID(SessionId, did);	2406
2		OH_GET_DOMAIN(did, d); /* Lock domain */	2407
2		OH_RESOURCE_GET(d, ResourceId, res);	2408
			2409
1		if (!(res->ResourceCapabilities & SAHPI_CAPABILITY_MANAGED_HOTSWAP)) {	2410
0		oh_release_domain(d); /* Unlock domain */	2411
0		return SA_ERR_HPI_CAPABILITY;	2412
		}	2413
			2414
1		rd = oh_get_resource_data(&(d->rpt), ResourceId);	2415
1		if (!rd) {	2416
0		dbg( "Can't find resource data for Resource %d in Domain %d",ResourceId,did);	2417
0		oh_release_domain(d); /* Unlock domain */	2418
0		return SA_ERR_HPI_INVALID_PARAMS;	2419
		}	2420
			2421
1		if (!rd->controlled) {	2422
1		oh_release_domain(d); /* Unlock domain */	2423
1		return SA_ERR_HPI_INVALID_CMD;	2424
		}	2425
			2426
		/* this was done in the old code, so we do it here */	2427
0		rd->controlled = 0;	2428
			2429
0		OH_HANDLER_GET(d, ResourceId, h);	2430
0		oh_release_domain(d); /* Unlock domain */	2431
			2432
0		set_hotswap_state = h->abi->set_hotswap_state;	2433
0		if (!set_hotswap_state) {	2434
0		return SA_ERR_HPI_INVALID_CMD;	2435
		}	2436
			2437
0		rv = set_hotswap_state(h->hnd, ResourceId, SAHPI_HS_STATE_ACTIVE);	2438
			2439
			2440
0		return rv;	2441
		}	2442
			2443
		SaErrorT SAHPI_API saHpiResourceInactiveSet (	2444
		SAHPI_IN SaHpiSessionIdT SessionId,	2445
		SAHPI_IN SaHpiResourceIdT ResourceId)	2446
3		{	2447
3		SaErrorT rv;	2448
		SaErrorT (*set_hotswap_state)(void *hnd, SaHpiResourceIdT rid,	2449
3		SaHpiHsStateT state);	2450
3		SaHpiRptEntryT *res;	2451
3		struct oh_handler *h;	2452
3		SaHpiDomainIdT did;	2453
3		struct oh_domain *d = NULL;	2454
3		struct oh_resource_data *rd;	2455
			2456
3		OH_CHECK_INIT_STATE(SessionId);	2457
2		OH_GET_DID(SessionId, did);	2458
2		OH_GET_DOMAIN(did, d); /* Lock domain */	2459
2		OH_RESOURCE_GET(d, ResourceId, res);	2460
			2461
1		if (!(res->ResourceCapabilities & SAHPI_CAPABILITY_MANAGED_HOTSWAP)) {	2462
0		oh_release_domain(d); /* Unlock domain */	2463
0		return SA_ERR_HPI_CAPABILITY;	2464
		}	2465
			2466
1		rd = oh_get_resource_data(&(d->rpt), ResourceId);	2467
1		if (!rd) {	2468
0		dbg("Can't find resource data for Resource %d in Domain %d",ResourceId,did);	2469
0		oh_release_domain(d); /* Unlock domain */	2470
0		return SA_ERR_HPI_INVALID_PARAMS;	2471
		}	2472
			2473
1		if (!rd->controlled) {	2474
1		oh_release_domain(d); /* Unlock domain */	2475
1		return SA_ERR_HPI_INVALID_CMD;	2476
		}	2477
			2478
0		rd->controlled = 0;	2479
			2480
0		OH_HANDLER_GET(d, ResourceId, h);	2481
0		oh_release_domain(d); /* Unlock domain */	2482
			2483
0		set_hotswap_state = h->abi->set_hotswap_state;	2484
0		if (!set_hotswap_state) {	2485
0		return SA_ERR_HPI_INVALID_CMD;	2486
		}	2487
			2488
0		rv = set_hotswap_state(h->hnd, ResourceId, SAHPI_HS_STATE_INACTIVE);	2489
			2490
0		return rv;	2491
		}	2492
			2493
		SaErrorT SAHPI_API saHpiAutoInsertTimeoutGet(	2494
		SAHPI_IN SaHpiSessionIdT SessionId,	2495
		SAHPI_OUT SaHpiTimeoutT *Timeout)	2496
8		{	2497
			2498
8		SaHpiDomainIdT did;	2499
			2500
8		if (!Timeout) {	2501
1		return SA_ERR_HPI_INVALID_PARAMS;	2502
		}	2503
			2504
7		OH_CHECK_INIT_STATE(SessionId);	2505
6		OH_GET_DID(SessionId, did);	2506
			2507
6		*Timeout = get_hotswap_auto_insert_timeout();	2508
			2509
6		return SA_OK;	2510
		}	2511
			2512
		SaErrorT SAHPI_API saHpiAutoInsertTimeoutSet(	2513
		SAHPI_IN SaHpiSessionIdT SessionId,	2514
		SAHPI_IN SaHpiTimeoutT Timeout)	2515
7		{	2516
7		SaHpiDomainIdT did;	2517
			2518
7		if (Timeout != SAHPI_TIMEOUT_IMMEDIATE &&	2519
		Timeout != SAHPI_TIMEOUT_BLOCK &&	2520
		Timeout < 0)	2521
0		return SA_ERR_HPI_INVALID_PARAMS;	2522
			2523
7		OH_CHECK_INIT_STATE(SessionId);	2524
6		OH_GET_DID(SessionId, did);	2525
			2526
6		set_hotswap_auto_insert_timeout(Timeout);	2527
			2528
6		return SA_OK;	2529
		}	2530
			2531
		SaErrorT SAHPI_API saHpiAutoExtractTimeoutGet(	2532
		SAHPI_IN SaHpiSessionIdT SessionId,	2533
		SAHPI_IN SaHpiResourceIdT ResourceId,	2534
		SAHPI_OUT SaHpiTimeoutT *Timeout)	2535
9		{	2536
9		SaHpiRptEntryT *res;	2537
9		struct oh_resource_data *rd;	2538
9		SaHpiDomainIdT did;	2539
9		struct oh_domain *d = NULL;	2540
			2541
9		if (!Timeout) {	2542
1		return SA_ERR_HPI_INVALID_PARAMS;	2543
		}	2544
			2545
8		OH_CHECK_INIT_STATE(SessionId);	2546
7		OH_GET_DID(SessionId, did);	2547
7		OH_GET_DOMAIN(did, d); /* Lock domain */	2548
7		OH_RESOURCE_GET(d, ResourceId, res);	2549
			2550
6		if (!(res->ResourceCapabilities & SAHPI_CAPABILITY_MANAGED_HOTSWAP)) {	2551
0		oh_release_domain(d); /* Unlock domain */	2552
0		return SA_ERR_HPI_CAPABILITY;	2553
		}	2554
			2555
6		rd = oh_get_resource_data(&(d->rpt), ResourceId);	2556
6		if (!rd) {	2557
0		dbg("Cannot find resource data for Resource %d in Domain %d",ResourceId,did);	2558
0		oh_release_domain(d); /* Unlock domain */	2559
0		return SA_ERR_HPI_INVALID_PARAMS;	2560
		}	2561
			2562
6		*Timeout = rd->auto_extract_timeout;	2563
6		oh_release_domain(d); /* Unlock domain */	2564
			2565
6		return SA_OK;	2566
		}	2567
			2568
		SaErrorT SAHPI_API saHpiAutoExtractTimeoutSet(	2569
		SAHPI_IN SaHpiSessionIdT SessionId,	2570
		SAHPI_IN SaHpiResourceIdT ResourceId,	2571
		SAHPI_IN SaHpiTimeoutT Timeout)	2572
8		{	2573
8		SaHpiRptEntryT *res;	2574
8		struct oh_resource_data *rd;	2575
8		SaHpiDomainIdT did;	2576
8		struct oh_domain *d = NULL;	2577
			2578
8		if (Timeout != SAHPI_TIMEOUT_IMMEDIATE &&	2579
		Timeout != SAHPI_TIMEOUT_BLOCK &&	2580
		Timeout < 0)	2581
0		return SA_ERR_HPI_INVALID_PARAMS;	2582
			2583
8		OH_CHECK_INIT_STATE(SessionId);	2584
7		OH_GET_DID(SessionId, did);	2585
7		OH_GET_DOMAIN(did, d); /* Lock domain */	2586
7		OH_RESOURCE_GET(d, ResourceId, res);	2587
			2588
6		if (!(res->ResourceCapabilities & SAHPI_CAPABILITY_MANAGED_HOTSWAP)) {	2589
0		oh_release_domain(d); /* Unlock domain */	2590
0		return SA_ERR_HPI_CAPABILITY;	2591
		}	2592
			2593
6		rd = oh_get_resource_data(&(d->rpt), ResourceId);	2594
6		if (!rd) {	2595
0		dbg("Cannot find resource data for Resource %d in Domain %d",ResourceId,did);	2596
0		oh_release_domain(d); /* Unlock domain */	2597
0		return SA_ERR_HPI_INVALID_PARAMS;	2598
		}	2599
			2600
6		rd->auto_extract_timeout = Timeout;	2601
6		oh_release_domain(d); /* Unlock domain */	2602
			2603
6		return SA_OK;	2604
		}	2605
			2606
		SaErrorT SAHPI_API saHpiHotSwapStateGet (	2607
		SAHPI_IN SaHpiSessionIdT SessionId,	2608
		SAHPI_IN SaHpiResourceIdT ResourceId,	2609
		SAHPI_OUT SaHpiHsStateT *State)	2610
12		{	2611
12		SaErrorT rv;	2612
		SaErrorT (*get_hotswap_state)(void *hnd, SaHpiResourceIdT rid,	2613
12		SaHpiHsStateT *state);	2614
12		SaHpiRptEntryT *res;	2615
12		struct oh_handler *h;	2616
12		SaHpiDomainIdT did;	2617
12		struct oh_domain *d = NULL;	2618
			2619
12		if (!State) {	2620
1		return SA_ERR_HPI_INVALID_PARAMS;	2621
		}	2622
			2623
11		OH_CHECK_INIT_STATE(SessionId);	2624
10		OH_GET_DID(SessionId, did);	2625
10		OH_GET_DOMAIN(did, d); /* Lock domain */	2626
10		OH_RESOURCE_GET(d, ResourceId, res);	2627
			2628
9		if (!(res->ResourceCapabilities & SAHPI_CAPABILITY_FRU)) {	2629
0		oh_release_domain(d); /* Unlock domain */	2630
0		return SA_ERR_HPI_CAPABILITY;	2631
		}	2632
			2633
9		OH_HANDLER_GET(d, ResourceId, h);	2634
9		oh_release_domain(d); /* Unlock domain */	2635
			2636
9		get_hotswap_state = h->abi->get_hotswap_state;	2637
9		if (!get_hotswap_state) {	2638
0		return SA_ERR_HPI_INVALID_CMD;	2639
		}	2640
			2641
9		rv = get_hotswap_state(h->hnd, ResourceId, State);	2642
			2643
9		return rv;	2644
		}	2645
			2646
		SaErrorT SAHPI_API saHpiHotSwapActionRequest (	2647
		SAHPI_IN SaHpiSessionIdT SessionId,	2648
		SAHPI_IN SaHpiResourceIdT ResourceId,	2649
		SAHPI_IN SaHpiHsActionT Action)	2650
13		{	2651
13		SaErrorT rv;	2652
		SaErrorT (*request_hotswap_action)(void *hnd, SaHpiResourceIdT rid,	2653
13		SaHpiHsActionT act);	2654
			2655
13		SaHpiRptEntryT *res;	2656
13		struct oh_handler *h;	2657
13		SaHpiDomainIdT did;	2658
13		struct oh_domain *d = NULL;	2659
			2660
13		if (!oh_lookup_hsaction(Action)) {	2661
1		return SA_ERR_HPI_INVALID_PARAMS;	2662
		}	2663
			2664
12		OH_CHECK_INIT_STATE(SessionId);	2665
11		OH_GET_DID(SessionId, did);	2666
11		OH_GET_DOMAIN(did, d); /* Lock domain */	2667
11		OH_RESOURCE_GET(d, ResourceId, res);	2668
			2669
10		if (!(res->ResourceCapabilities & SAHPI_CAPABILITY_MANAGED_HOTSWAP)) {	2670
0		oh_release_domain(d); /* Unlock domain */	2671
0		return SA_ERR_HPI_CAPABILITY;	2672
		}	2673
			2674
10		OH_HANDLER_GET(d, ResourceId, h);	2675
10		oh_release_domain(d); /* Unlock domain */	2676
			2677
10		request_hotswap_action = h->abi->request_hotswap_action;	2678
10		if (!request_hotswap_action) {	2679
0		return SA_ERR_HPI_INVALID_CMD;	2680
		}	2681
			2682
10		rv = request_hotswap_action(h->hnd, ResourceId, Action);	2683
			2684
10		oh_get_events();	2685
			2686
10		return rv;	2687
		}	2688
			2689
		SaErrorT SAHPI_API saHpiHotSwapIndicatorStateGet (	2690
		SAHPI_IN SaHpiSessionIdT SessionId,	2691
		SAHPI_IN SaHpiResourceIdT ResourceId,	2692
		SAHPI_OUT SaHpiHsIndicatorStateT *State)	2693
7		{	2694
7		SaErrorT rv;	2695
		SaErrorT (*get_indicator_state)(void *hnd, SaHpiResourceIdT id,	2696
7		SaHpiHsIndicatorStateT *state);	2697
7		SaHpiRptEntryT *res;	2698
7		struct oh_handler *h;	2699
7		SaHpiDomainIdT did;	2700
7		struct oh_domain *d = NULL;	2701
			2702
7		if (!State) {	2703
1		return SA_ERR_HPI_INVALID_PARAMS;	2704
		}	2705
			2706
6		OH_CHECK_INIT_STATE(SessionId);	2707
5		OH_GET_DID(SessionId, did);	2708
5		OH_GET_DOMAIN(did, d); /* Lock domain */	2709
5		OH_RESOURCE_GET(d, ResourceId, res);	2710
			2711
4		if (!(res->ResourceCapabilities & SAHPI_CAPABILITY_MANAGED_HOTSWAP)) {	2712
0		oh_release_domain(d); /* Unlock domain */	2713
0		return SA_ERR_HPI_CAPABILITY;	2714
		}	2715
			2716
4		OH_HANDLER_GET(d, ResourceId, h);	2717
4		oh_release_domain(d); /* Unlock domain */	2718
			2719
4		get_indicator_state = h->abi->get_indicator_state;	2720
4		if (!get_indicator_state) {	2721
0		return SA_ERR_HPI_INVALID_CMD;	2722
		}	2723
			2724
4		rv = get_indicator_state(h->hnd, ResourceId, State);	2725
			2726
4		return rv;	2727
		}	2728
			2729
		SaErrorT SAHPI_API saHpiHotSwapIndicatorStateSet (	2730
		SAHPI_IN SaHpiSessionIdT SessionId,	2731
		SAHPI_IN SaHpiResourceIdT ResourceId,	2732
		SAHPI_IN SaHpiHsIndicatorStateT State)	2733
7		{	2734
7		SaErrorT rv;	2735
		SaErrorT (*set_indicator_state)(void *hnd, SaHpiResourceIdT id,	2736
7		SaHpiHsIndicatorStateT state);	2737
7		SaHpiRptEntryT *res;	2738
7		struct oh_handler *h;	2739
7		SaHpiDomainIdT did;	2740
7		struct oh_domain *d = NULL;	2741
			2742
7		if (!oh_lookup_hsindicatorstate(State)) {	2743
1		return SA_ERR_HPI_INVALID_PARAMS;	2744
		}	2745
			2746
6		OH_CHECK_INIT_STATE(SessionId);	2747
5		OH_GET_DID(SessionId, did);	2748
5		OH_GET_DOMAIN(did, d); /* Lock domain */	2749
5		OH_RESOURCE_GET(d, ResourceId, res);	2750
			2751
4		if (!(res->ResourceCapabilities & SAHPI_CAPABILITY_MANAGED_HOTSWAP)) {	2752
0		oh_release_domain(d); /* Unlock domain */	2753
0		return SA_ERR_HPI_CAPABILITY;	2754
		}	2755
			2756
4		OH_HANDLER_GET(d, ResourceId, h);	2757
4		oh_release_domain(d); /* Unlock domain */	2758
			2759
4		set_indicator_state = h->abi->set_indicator_state;	2760
4		if (!set_indicator_state) {	2761
0		return SA_ERR_HPI_INVALID_CMD;	2762
		}	2763
			2764
4		rv = set_indicator_state(h->hnd, ResourceId, State);	2765
			2766
4		return rv;	2767
		}	2768
			2769
		/*******************************************************************************	2770
		*	2771
		* Configuration Function(s)	2772
		*	2773
		******************************************************************************/	2774
			2775
		SaErrorT SAHPI_API saHpiParmControl (	2776
		SAHPI_IN SaHpiSessionIdT SessionId,	2777
		SAHPI_IN SaHpiResourceIdT ResourceId,	2778
		SAHPI_IN SaHpiParmActionT Action)	2779
6		{	2780
6		SaErrorT rv;	2781
6		SaErrorT (*control_parm)(void *, SaHpiResourceIdT, SaHpiParmActionT);	2782
6		SaHpiRptEntryT *res;	2783
6		struct oh_handler *h;	2784
6		SaHpiDomainIdT did;	2785
6		struct oh_domain *d = NULL;	2786
			2787
6		if (!oh_lookup_parmaction(Action)) {	2788
1		return SA_ERR_HPI_INVALID_PARAMS;	2789
		}	2790
			2791
5		OH_CHECK_INIT_STATE(SessionId);	2792
4		OH_GET_DID(SessionId, did);	2793
4		OH_GET_DOMAIN(did, d); /* Lock domain */	2794
4		OH_RESOURCE_GET(d, ResourceId, res);	2795
			2796
3		if (!(res->ResourceCapabilities & SAHPI_CAPABILITY_CONFIGURATION)) {	2797
0		oh_release_domain(d); /* Unlock domain */	2798
0		return SA_ERR_HPI_CAPABILITY;	2799
		}	2800
			2801
3		OH_HANDLER_GET(d, ResourceId, h);	2802
3		oh_release_domain(d); /* Unlock domain */	2803
			2804
3		control_parm = h->abi->control_parm;	2805
3		if (!control_parm) {	2806
0		return SA_ERR_HPI_INVALID_CMD;	2807
		}	2808
			2809
3		rv = control_parm(h->hnd, ResourceId, Action);	2810
			2811
3		return rv;	2812
		}	2813
			2814
		/*******************************************************************************	2815
		*	2816
		* Reset Functions	2817
		*	2818
		******************************************************************************/	2819
			2820
			2821
		SaErrorT SAHPI_API saHpiResourceResetStateGet (	2822
		SAHPI_IN SaHpiSessionIdT SessionId,	2823
		SAHPI_IN SaHpiResourceIdT ResourceId,	2824
		SAHPI_OUT SaHpiResetActionT *ResetAction)	2825
3		{	2826
3		SaErrorT rv;	2827
3		SaErrorT (*get_func)(void *, SaHpiResourceIdT, SaHpiResetActionT *);	2828
			2829
3		SaHpiRptEntryT *res;	2830
3		struct oh_handler *h;	2831
3		SaHpiDomainIdT did;	2832
3		struct oh_domain *d = NULL;	2833
			2834
3		if (!ResetAction) {	2835
1		return SA_ERR_HPI_INVALID_PARAMS;	2836
		}	2837
			2838
2		OH_CHECK_INIT_STATE(SessionId);	2839
1		OH_GET_DID(SessionId, did);	2840
1		OH_GET_DOMAIN(did, d); /* Lock domain */	2841
1		OH_RESOURCE_GET(d, ResourceId, res);	2842
			2843
0		if (!(res->ResourceCapabilities & SAHPI_CAPABILITY_RESET)) {	2844
0		oh_release_domain(d); /* Unlock domain */	2845
0		return SA_ERR_HPI_CAPABILITY;	2846
		}	2847
			2848
0		OH_HANDLER_GET(d, ResourceId, h);	2849
0		oh_release_domain(d); /* Unlock domain */	2850
			2851
0		get_func = h->abi->get_reset_state;	2852
0		if (!get_func) {	2853
0		return SA_ERR_HPI_INVALID_CMD;	2854
		}	2855
			2856
0		rv = get_func(h->hnd, ResourceId, ResetAction);	2857
			2858
0		return rv;	2859
		}	2860
			2861
		SaErrorT SAHPI_API saHpiResourceResetStateSet (	2862
		SAHPI_IN SaHpiSessionIdT SessionId,	2863
		SAHPI_IN SaHpiResourceIdT ResourceId,	2864
		SAHPI_IN SaHpiResetActionT ResetAction)	2865
4		{	2866
4		SaErrorT rv;	2867
4		SaErrorT (*set_func)(void *, SaHpiResourceIdT, SaHpiResetActionT);	2868
4		SaHpiRptEntryT *res;	2869
4		struct oh_handler *h;	2870
4		SaHpiDomainIdT did;	2871
4		struct oh_domain *d = NULL;	2872
			2873
4		if (!oh_lookup_resetaction(ResetAction)) {	2874
1		return SA_ERR_HPI_INVALID_PARAMS;	2875
		}	2876
			2877
3		OH_CHECK_INIT_STATE(SessionId);	2878
2		OH_GET_DID(SessionId, did);	2879
2		OH_GET_DOMAIN(did, d); /* Lock domain */	2880
2		OH_RESOURCE_GET(d, ResourceId, res);	2881
			2882
1		if (!(res->ResourceCapabilities & SAHPI_CAPABILITY_RESET)) {	2883
1		oh_release_domain(d); /* Unlock domain */	2884
1		return SA_ERR_HPI_CAPABILITY;	2885
		}	2886
			2887
0		OH_HANDLER_GET(d, ResourceId, h);	2888
0		oh_release_domain(d); /* Unlock domain */	2889
			2890
0		set_func = h->abi->set_reset_state;	2891
0		if (!set_func) {	2892
0		return SA_ERR_HPI_INVALID_CMD;	2893
		}	2894
			2895
0		rv = set_func(h->hnd, ResourceId, ResetAction);	2896
			2897
0		return rv;	2898
		}	2899
			2900
		/*******************************************************************************	2901
		*	2902
		* Power Functions	2903
		*	2904
		******************************************************************************/	2905
			2906
		SaErrorT SAHPI_API saHpiResourcePowerStateGet (	2907
		SAHPI_IN SaHpiSessionIdT SessionId,	2908
		SAHPI_IN SaHpiResourceIdT ResourceId,	2909
		SAHPI_OUT SaHpiPowerStateT *State)	2910
9		{	2911
9		SaErrorT rv;	2912
		SaErrorT (*get_power_state)(void *hnd, SaHpiResourceIdT id,	2913
9		SaHpiPowerStateT *state);	2914
9		SaHpiRptEntryT *res;	2915
9		struct oh_handler *h;	2916
9		SaHpiDomainIdT did;	2917
9		struct oh_domain *d = NULL;	2918
			2919
9		if (!State) {	2920
1		return SA_ERR_HPI_INVALID_PARAMS;	2921
		}	2922
			2923
8		OH_CHECK_INIT_STATE(SessionId);	2924
7		OH_GET_DID(SessionId, did);	2925
7		OH_GET_DOMAIN(did, d); /* Lock domain */	2926
7		OH_RESOURCE_GET(d, ResourceId, res);	2927
			2928
6		if (!(res->ResourceCapabilities & SAHPI_CAPABILITY_POWER)) {	2929
0		oh_release_domain(d); /* Unlock domain */	2930
0		return SA_ERR_HPI_CAPABILITY;	2931
		}	2932
			2933
6		OH_HANDLER_GET(d, ResourceId, h);	2934
6		oh_release_domain(d); /* Unlock domain */	2935
			2936
6		get_power_state = h->abi->get_power_state;	2937
6		if (!get_power_state) {	2938
0		return SA_ERR_HPI_INVALID_CMD;	2939
		}	2940
			2941
6		rv = get_power_state(h->hnd, ResourceId, State);	2942
			2943
6		return rv;	2944
		}	2945
			2946
		SaErrorT SAHPI_API saHpiResourcePowerStateSet (	2947
		SAHPI_IN SaHpiSessionIdT SessionId,	2948
		SAHPI_IN SaHpiResourceIdT ResourceId,	2949
		SAHPI_IN SaHpiPowerStateT State)	2950
9		{	2951
9		SaErrorT rv;	2952
		SaErrorT (*set_power_state)(void *hnd, SaHpiResourceIdT id,	2953
9		SaHpiPowerStateT state);	2954
9		SaHpiRptEntryT *res;	2955
9		struct oh_handler *h;	2956
9		SaHpiDomainIdT did;	2957
9		struct oh_domain *d = NULL;	2958
			2959
9		if (!oh_lookup_powerstate(State)) {	2960
1		return SA_ERR_HPI_INVALID_PARAMS;	2961
		}	2962
			2963
8		OH_CHECK_INIT_STATE(SessionId);	2964
7		OH_GET_DID(SessionId, did);	2965
7		OH_GET_DOMAIN(did, d); /* Lock domain */	2966
7		OH_RESOURCE_GET(d, ResourceId, res);	2967
			2968
6		if (!(res->ResourceCapabilities & SAHPI_CAPABILITY_POWER)) {	2969
0		oh_release_domain(d); /* Unlock domain */	2970
0		return SA_ERR_HPI_CAPABILITY;	2971
		}	2972
			2973
6		OH_HANDLER_GET(d, ResourceId, h);	2974
6		oh_release_domain(d); /* Unlock domain */	2975
			2976
6		set_power_state = h->abi->set_power_state;	2977
6		if (!set_power_state) {	2978
0		return SA_ERR_HPI_INVALID_CMD;	2979
		}	2980
			2981
6		rv = set_power_state(h->hnd, ResourceId, State);	2982
			2983
6		return rv;	2984
		}	2985
			2986
			2987