author | Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com> |
Tue, 31 Aug 2010 16:34:26 +0300 | |
branch | RCL_3 |
changeset 256 | c1f20ce4abcf |
parent 0 | a41df078684a |
child 257 | 3e88ff8f41d5 |
permissions | -rw-r--r-- |
0 | 1 |
// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). |
2 |
// All rights reserved. |
|
3 |
// This component and the accompanying materials are made available |
|
4 |
// under the terms of the License "Eclipse Public License v1.0" |
|
5 |
// which accompanies this distribution, and is available |
|
6 |
// at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 |
// |
|
8 |
// Initial Contributors: |
|
9 |
// Nokia Corporation - initial contribution. |
|
10 |
// |
|
11 |
// Contributors: |
|
12 |
// |
|
13 |
// Description: |
|
14 |
// e32/include/iic_transaction.inl |
|
15 |
// |
|
16 |
||
17 |
inline TIicBusTransfer::TIicBusTransfer() |
|
18 |
: iBuffer(NULL), iNext(NULL), iTransaction(NULL) {} |
|
19 |
||
20 |
inline TIicBusTransfer::TIicBusTransfer(TReqType aType, TInt8 aGranularity, TDes8* aBuffer) : iType((TInt8)aType), iNext(NULL) |
|
21 |
{ |
|
22 |
__ASSERT_ALWAYS(aBuffer && aGranularity && aBuffer->Size()%(((aGranularity-1)>>3)+1)==0,Kern::Fault("TIicBusTransfer",__LINE__)); |
|
23 |
iBufGranularity=aGranularity; |
|
24 |
iBuffer=aBuffer; |
|
25 |
} |
|
26 |
||
27 |
inline void TIicBusTransfer::LinkAfter(TIicBusTransfer* aPrev) |
|
28 |
{ |
|
29 |
__ASSERT_ALWAYS(aPrev && aPrev->WordWidth()==iBufGranularity,Kern::Fault("LinkAfter",__LINE__)); |
|
30 |
iNext=aPrev; |
|
31 |
} |
|
32 |
||
33 |
inline TInt8 TIicBusTransfer::WordWidth() |
|
34 |
{return iBufGranularity;} |
|
35 |
||
36 |
inline TIicBusTransfer::TReqType TIicBusTransfer::Direction() |
|
37 |
{return (TIicBusTransfer::TReqType)iType;} |
|
38 |
||
39 |
inline TInt TIicBusTransfer::Length() |
|
40 |
{ |
|
41 |
TInt8 granularityInBytes = (TInt8)(((iBufGranularity-1)>>3)+1); |
|
42 |
return(iBuffer->Size()/granularityInBytes); |
|
43 |
} |
|
44 |
||
45 |
inline const TIicBusTransfer* TIicBusTransfer::Next() |
|
46 |
{return iNext;} |
|
47 |
||
48 |
inline TInt TIicBusTransfer::SetTransferData(TReqType aType, TInt8 aGranularity, TDes8* aBuffer) |
|
49 |
{ |
|
50 |
__ASSERT_ALWAYS(aBuffer && aGranularity && aBuffer->Size()%(((aGranularity-1)>>3)+1)==0,Kern::Fault("TIicBusTransfer",__LINE__)); |
|
51 |
if((iTransaction==NULL)||(iTransaction->State()==TIicBusTransaction::EFree)) |
|
52 |
{ |
|
53 |
iType = (TInt8)aType; |
|
54 |
iBufGranularity = aGranularity; |
|
55 |
iBuffer = aBuffer; |
|
56 |
return KErrNone; |
|
57 |
} |
|
58 |
return KErrInUse; |
|
59 |
} |
|
60 |
||
61 |
inline TIicBusTransaction::TIicBusTransaction(): iHeader(NULL), iFlags(NULL), iState(EFree), |
|
62 |
iHalfDuplexTrans(NULL), iFullDuplexTrans(NULL), iCallback(NULL){} |
|
63 |
||
64 |
inline TIicBusTransaction::TIicBusTransaction(TDes8* aHeader, TIicBusTransfer* aHdTrans, TInt aPriority) : |
|
65 |
iHeader(aHeader), iFlags(NULL), iState(EFree), iHalfDuplexTrans(aHdTrans), |
|
66 |
iFullDuplexTrans(NULL), iCallback(NULL) |
|
67 |
{ |
|
256
c1f20ce4abcf
Revision: 201035
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
68 |
//Check that the requested priority is at least zero and less than KNumTrancPriorities. |
c1f20ce4abcf
Revision: 201035
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
69 |
__ASSERT_ALWAYS(((aPriority<KNumTrancPriorities)&&(aPriority>=0)),Kern::Fault("TIicBusTransaction",__LINE__)); |
0 | 70 |
__ASSERT_ALWAYS(aHeader && aHdTrans,Kern::Fault("TIicBusTransaction",__LINE__)); |
71 |
iKey = aPriority; |
|
72 |
} |
|
73 |
||
74 |
inline TIicBusTransaction::~TIicBusTransaction() |
|
75 |
{__ASSERT_ALWAYS(iState==TIicBusTransaction::EFree,Kern::Fault("~TIicBusTransaction",__LINE__));} |
|
76 |
||
77 |
inline TInt TIicBusTransaction::SetHalfDuplexTrans(TDes8* aHeader, TIicBusTransfer* aHdTrans) |
|
78 |
{ |
|
79 |
__ASSERT_ALWAYS(aHeader && aHdTrans, Kern::Fault("SetHalfDuplexTrans",__LINE__)); |
|
80 |
__ASSERT_ALWAYS(iState==TIicBusTransaction::EFree,Kern::Fault("SetHalfDuplexTrans",__LINE__)); |
|
81 |
iHeader = aHeader; |
|
82 |
iHalfDuplexTrans = aHdTrans; |
|
83 |
while(aHdTrans) |
|
84 |
{ |
|
85 |
aHdTrans->iTransaction=this; |
|
86 |
aHdTrans = (TIicBusTransfer*)(aHdTrans->Next()); |
|
87 |
} |
|
88 |
return KErrNone; |
|
89 |
} |
|
90 |
||
91 |
// The client interface for setting full duplex transaction: the API checks that it is possible to have the 2 transactions done in parallel. |
|
92 |
// It does not check if the channel supports full duplex, so the transaction may still fail at queuing time. |
|
93 |
inline TInt TIicBusTransaction::SetFullDuplexTrans(TIicBusTransfer* aFdTrans) |
|
94 |
{ |
|
95 |
__ASSERT_ALWAYS(aFdTrans,Kern::Fault("SetFullDuplexTrans",__LINE__)); |
|
96 |
__ASSERT_ALWAYS(iState==TIicBusTransaction::EFree,Kern::Fault("SetFullDuplexTrans",__LINE__)); |
|
97 |
TIicBusTransfer* local = iHalfDuplexTrans; |
|
98 |
TIicBusTransfer* remote = aFdTrans; |
|
99 |
while(local && remote) |
|
100 |
{ |
|
101 |
if(local->Direction()==remote->Direction()) |
|
102 |
return KErrNotSupported; |
|
103 |
if(local->Next() && local->Length()<remote->Length()) |
|
104 |
return KErrNotSupported; |
|
105 |
if(remote->Next() && remote->Length()<local->Length()) |
|
106 |
return KErrNotSupported; |
|
107 |
local = (TIicBusTransfer*)(local->Next()); |
|
108 |
remote = (TIicBusTransfer*)(remote->Next()); |
|
109 |
} |
|
110 |
iFullDuplexTrans = aFdTrans; |
|
111 |
while(aFdTrans) |
|
112 |
{ |
|
113 |
aFdTrans->iTransaction=this; |
|
114 |
aFdTrans = (TIicBusTransfer*)(aFdTrans->Next()); |
|
115 |
} |
|
116 |
return KErrNone; |
|
117 |
} |
|
118 |
||
119 |
inline TInt TIicBusTransaction::RemoveTrans(TIicBusTransfer* aTrans) |
|
120 |
{ |
|
121 |
__ASSERT_ALWAYS(aTrans,Kern::Fault("RemoveTrans",__LINE__)); |
|
122 |
__ASSERT_ALWAYS(iState==TIicBusTransaction::EFree,Kern::Fault("RemoveTrans",__LINE__)); |
|
123 |
TIicBusTransfer* ptr = aTrans; |
|
124 |
while(ptr!=NULL) |
|
125 |
{ |
|
126 |
ptr->iTransaction = NULL; |
|
127 |
ptr = (TIicBusTransfer*)(ptr->Next()); |
|
128 |
} |
|
129 |
aTrans=NULL; |
|
130 |
return KErrNone; |
|
131 |
} |
|
132 |
||
133 |
inline TInt TIicBusTransaction::RemoveHalfDuplexTrans() |
|
134 |
{return RemoveTrans(iHalfDuplexTrans);}; |
|
135 |
||
136 |
inline TInt TIicBusTransaction::RemoveFullDuplexTrans() |
|
137 |
{return RemoveTrans(iFullDuplexTrans);}; |
|
138 |
||
139 |
inline TUint TIicBusTransaction::Flags() |
|
140 |
{return iFlags;} |
|
141 |
||
142 |
inline TIicBusTransaction::TIicBusTransaction(TDes8* aHeader, TIicBusTransfer* aHdTrans, TUint8 aFlags, TInt aPriority) : |
|
143 |
iHeader(aHeader), iFlags(aFlags), iHalfDuplexTrans(aHdTrans), iFullDuplexTrans(NULL), iCallback(NULL) |
|
144 |
{ |
|
145 |
__ASSERT_ALWAYS(aHeader && aHdTrans,Kern::Fault("TIicBusTransaction",__LINE__)); |
|
146 |
iKey = aPriority; |
|
147 |
} |
|
148 |
||
149 |
inline TUint8 TIicBusTransaction::State() |
|
150 |
{return iState;} |
|
151 |
||
152 |
inline TInt TIicBusTransaction::GetBusId() |
|
153 |
{return iBusId;} |
|
154 |
||
155 |
inline TIicBusCallback::TIicBusCallback(TIicBusCbFn aFn, TAny* aPtr, TDfcQue* aQue, TInt aPriority) |
|
156 |
: TDfc(DfcFunc, this, aQue, aPriority), iTransaction(NULL), iParam(aPtr), iCallback(aFn) {} |
|
157 |
||
158 |
inline TIicBusCallback::~TIicBusCallback() |
|
159 |
{__ASSERT_ALWAYS(!iTransaction || iTransaction->State()==TIicBusTransaction::EFree,Kern::Fault("~TIicBusCallback",__LINE__));} |
|
160 |
||
161 |
inline void TIicBusCallback::DfcFunc(TAny* aPtr) |
|
162 |
{ |
|
163 |
TIicBusCallback* pCb = (TIicBusCallback*) aPtr; |
|
164 |
pCb->iCallback(pCb->iTransaction, pCb->iBusId, pCb->iResult, pCb->iParam); |
|
165 |
} |
|
166 |
||
167 |
inline TIicBusSlaveCallback::TIicBusSlaveCallback(TIicBusSlaveCbFn aFn, TAny* aPtr, TDfcQue* aQue, TInt aPriority): |
|
168 |
TDfc(DfcFunc, this, aQue, aPriority), iParam(aPtr), iCallback(aFn) { } |
|
169 |
||
170 |
inline void TIicBusSlaveCallback::SetReturn(TInt aRet) |
|
171 |
{iReturn=aRet;} |
|
172 |
||
173 |
inline void TIicBusSlaveCallback::SetTxWords(TInt16 aTxWords) |
|
174 |
{iTxWords=aTxWords;} |
|
175 |
||
176 |
inline void TIicBusSlaveCallback::SetRxWords(TInt16 aRxWords) |
|
177 |
{iRxWords=aRxWords;} |
|
178 |
||
179 |
inline TInt TIicBusSlaveCallback::GetTrigger() |
|
180 |
{return iTrigger;} |
|
181 |
||
182 |
inline void TIicBusSlaveCallback::SetTrigger(TInt aTrigger) |
|
183 |
{iTrigger = aTrigger;} |
|
184 |
||
185 |
inline TIicBusTransactionPreamble::TIicBusTransactionPreamble(TDes8* aHeader, TIicBusTransfer* aHdTrans, TIicBusPreamble aPreamble, TAny* aArg, TInt aPriority) : |
|
186 |
TIicBusTransaction(aHeader, aHdTrans, KTransactionWithPreamble, aPriority), iPreamble(aPreamble), iPreambleArg(aArg) |
|
187 |
{} |
|
188 |
||
189 |
inline TIicBusTransactionPreamble::TIicBusTransactionPreamble(TDes8* aHeader, TIicBusTransfer* aHdTrans, TIicBusPreamble aPreamble, TAny* aArg, TUint8 aFlags, TInt aPriority) : |
|
190 |
TIicBusTransaction(aHeader, aHdTrans, aFlags, aPriority), iPreamble(aPreamble), iPreambleArg(aArg) |
|
191 |
{} |
|
192 |
||
193 |
inline TIicBusTransactionMultiTransc::TIicBusTransactionMultiTransc(TDes8* aHeader, TIicBusTransfer* aHdTrans, TIicBusMultiTranscCbFn aMultiTransc, TAny* aArg, TInt aPriority) : |
|
194 |
TIicBusTransaction(aHeader, aHdTrans, KTransactionWithMultiTransc, aPriority), iMultiTransc(aMultiTransc), iMultiTranscArg(aArg) |
|
195 |
{} |
|
196 |
||
197 |
inline TIicBusTransactionPreambleExt::TIicBusTransactionPreambleExt(TDes8* aHeader, TIicBusTransfer* aHdTrans, |
|
198 |
TIicBusPreamble aPreamble, TAny* aPreambleArg, |
|
199 |
TIicBusMultiTranscCbFn aMultiTransc, TAny* aMultiTranscArg, TInt aPriority) : |
|
200 |
TIicBusTransactionPreamble(aHeader, aHdTrans, aPreamble, aPreambleArg, KTransactionWithPreamble|KTransactionWithMultiTransc, aPriority), |
|
201 |
iMultiTransc(aMultiTransc), iMultiTranscArg(aMultiTranscArg) |
|
202 |
{} |
|
203 |
||
204 |
inline static TInt CreateSpiBuf(TConfigSpiBufV01*& aBuf, |
|
205 |
TSpiWordWidth aWordWidth, |
|
206 |
TInt32 aClkSpeedHz, |
|
207 |
TSpiClkMode aClkMode, |
|
208 |
TInt32 aTimeoutPeriod, |
|
209 |
TEndianness aEndianness, |
|
210 |
TBitOrder aBitOrder, |
|
211 |
TUint aTransactionWaitCycles, |
|
212 |
TSpiSsPinMode aSSPinActiveMode) |
|
213 |
// Utility function to create a buffer for the SPI bus |
|
214 |
{ |
|
215 |
aBuf = new TConfigSpiBufV01(); |
|
216 |
if(aBuf==NULL) |
|
217 |
return KErrNoMemory; |
|
218 |
TConfigSpiV01 *buf = &((*aBuf)()); |
|
219 |
buf->iWordWidth = aWordWidth; |
|
220 |
buf->iClkSpeedHz = aClkSpeedHz; |
|
221 |
buf->iClkMode = aClkMode; |
|
222 |
buf->iTimeoutPeriod = aTimeoutPeriod; |
|
223 |
buf->iEndianness = aEndianness; |
|
224 |
buf->iBitOrder = aBitOrder; |
|
225 |
buf->iTransactionWaitCycles = aTransactionWaitCycles; |
|
226 |
buf->iSSPinActiveMode = aSSPinActiveMode; |
|
227 |
return KErrNone; |
|
228 |
} |
|
229 |
||
230 |
inline static TInt CreateI2cBuf(TConfigI2cBufV01*& aBuf, |
|
231 |
TI2cAddrType aAddrType, |
|
232 |
TInt32 aClkSpeedHz, |
|
233 |
TEndianness aEndianness, |
|
234 |
TInt32 aTimeoutPeriod) |
|
235 |
// Utility function to create a buffer for the I2C bus |
|
236 |
{ |
|
237 |
aBuf = new TConfigI2cBufV01(); |
|
238 |
if(aBuf==NULL) |
|
239 |
return KErrNoMemory; |
|
240 |
TConfigI2cV01 *buf = &((*aBuf)()); |
|
241 |
buf->iAddrType = aAddrType; |
|
242 |
buf->iClkSpeedHz = aClkSpeedHz; |
|
243 |
buf->iEndianness = aEndianness; |
|
244 |
buf->iTimeoutPeriod = aTimeoutPeriod; |
|
245 |
return KErrNone; |
|
246 |
} |