13 * |
13 * |
14 * Description: USB driver for test |
14 * Description: USB driver for test |
15 * |
15 * |
16 */ |
16 */ |
17 |
17 |
|
18 #ifndef __devicePDD_H__ |
18 #include "webcamera_pdd.h" |
19 #include "webcamera_pdd.h" |
19 #include <webcamera_driver.h> |
20 #endif |
|
21 //#include <webcamera_driver.h> |
20 |
22 |
21 #define DP(format...) Kern::Printf(format) |
23 #define DP(format...) Kern::Printf(format) |
22 |
24 |
23 //Name for PDD |
25 //Name for PDD |
24 _LIT(KWebcameraPddName,"WebcameraDevice.pdd"); |
26 _LIT(KWebcameraPddName,"WebcameraDevice.pdd"); |
25 |
27 |
26 // --------------------------------------------------------------- |
|
27 // --------------------------------------------------------------- |
|
28 |
28 |
29 DWebcameraPddFactory::DWebcameraPddFactory() |
29 DWebcameraPddFactory::DWebcameraPddFactory() |
30 { |
30 { |
31 DP("DWebcameraPddFactory::DWebcameraPddFactory()"); |
31 DP("DWebcameraPddFactory::DWebcameraPddFactory()"); |
32 iVersion=TVersion(KCommsMajorVersionNumber,KCommsMinorVersionNumber,KCommsBuildVersionNumber); |
32 iVersion = TVersion(KCommsMajorVersionNumber, KCommsMinorVersionNumber, KCommsBuildVersionNumber); |
33 } |
33 } |
34 |
34 |
35 TInt DWebcameraPddFactory::Install() |
35 TInt DWebcameraPddFactory::Install() |
36 { |
36 { |
37 DP("DWebcameraPddFactory::Install"); |
37 DP("DWebcameraPddFactory::Install"); |
38 return SetName(&KWebcameraPddName); |
38 return SetName(&KWebcameraPddName); |
39 } |
39 } |
40 |
40 |
41 void DWebcameraPddFactory::GetCaps(TDes8 &aDes) const |
41 void DWebcameraPddFactory::GetCaps(TDes8 &aDes) const |
42 { |
42 { |
43 DP("DWebcameraPddFactory::GetCaps start"); |
43 DP("DWebcameraPddFactory::GetCaps start"); |
44 RWebcameraDevice::TCaps capsBuf; |
44 RWebcameraDevice::TCaps capsBuf; |
45 capsBuf.iVersion = iVersion; |
45 capsBuf.iVersion = iVersion; |
46 aDes.FillZ(aDes.MaxLength()); |
46 aDes.FillZ(aDes.MaxLength()); |
47 TInt size=sizeof(capsBuf); |
47 TInt size = sizeof(capsBuf); |
48 if(size>aDes.MaxLength()) |
48 if (size>aDes.MaxLength()) |
49 { |
49 { |
50 size=aDes.MaxLength(); |
50 size=aDes.MaxLength(); |
51 } |
51 } |
52 aDes.Copy((TUint8*)&capsBuf,size); |
52 aDes.Copy((TUint8*)&capsBuf, size); |
53 DP("DWebcameraPddFactory::GetCaps end"); |
53 DP("DWebcameraPddFactory::GetCaps end"); |
54 } |
54 } |
55 |
55 |
56 TInt DWebcameraPddFactory::Create(DBase*& aChannel, TInt aUnit, const TDesC8* anInfo, const TVersion& aVer) |
56 TInt DWebcameraPddFactory::Create(DBase*& aChannel, TInt aUnit, const TDesC8* anInfo, const TVersion& aVer) |
57 { |
57 { |
58 DP("DWebcameraPddFactory::Create start"); |
58 DP("DWebcameraPddFactory::Create start"); |
59 DWebcameraDriver* pD=new DWebcameraDriver; |
59 DWebcameraDriver* pD = new DWebcameraDriver; |
60 aChannel=pD; |
60 aChannel = pD; |
61 TInt r=KErrNoMemory; |
61 TInt r = KErrNoMemory; |
62 if (pD) |
62 if (pD) |
63 { |
63 { |
64 r=pD->DoCreate(aUnit,anInfo); |
64 r = pD->DoCreate(aUnit,anInfo); |
65 } |
65 } |
66 DP("DWebcameraPddFactory::Create end"); |
66 DP("DWebcameraPddFactory::Create end"); |
67 return r; |
67 return r; |
68 } |
68 } |
69 |
69 |
70 TInt DWebcameraPddFactory::Validate(TInt aUnit, const TDesC8* /*anInfo*/, const TVersion& aVer) |
70 TInt DWebcameraPddFactory::Validate(TInt aUnit, const TDesC8* /*anInfo*/, const TVersion& aVer) |
71 { |
71 { |
72 DP("DWebcameraPddFactory::Validate start"); |
72 DP("DWebcameraPddFactory::Validate start"); |
73 if ((!Kern::QueryVersionSupported(iVersion,aVer)) || |
73 if ((!Kern::QueryVersionSupported(iVersion,aVer)) || |
74 (!Kern::QueryVersionSupported(aVer,TVersion(KMinimumLddMajorVersion,KMinimumLddMinorVersion,KMinimumLddBuild)))) |
74 (!Kern::QueryVersionSupported(aVer, TVersion(KMinimumLddMajorVersion, KMinimumLddMinorVersion, KMinimumLddBuild)))) |
75 { |
75 { |
76 return KErrNotSupported; |
76 return KErrNotSupported; |
77 } |
77 } |
78 DP("DWebcameraPddFactory::Validate end"); |
78 DP("DWebcameraPddFactory::Validate end"); |
79 return KErrNone; |
79 return KErrNone; |
80 } |
80 } |
81 |
|
82 // --------------------------------------------------------------- |
|
83 // --------------------------------------------------------------- |
|
84 |
81 |
85 DWebcameraDriver::DWebcameraDriver() |
82 DWebcameraDriver::DWebcameraDriver() |
86 { |
83 { |
87 DP("DWebcameraDriver::DWebcameraDriver start"); |
84 DP("DWebcameraDriver::DWebcameraDriver start"); |
88 DP("DWebcameraDriver::DWebcameraDriver end"); |
85 DP("DWebcameraDriver::DWebcameraDriver end"); |
89 } |
86 } |
90 |
87 |
91 DWebcameraDriver::~DWebcameraDriver() |
88 DWebcameraDriver::~DWebcameraDriver() |
92 { |
89 { |
93 DP("DWebcameraDriver::~DWebcameraDriver start"); |
90 DP("DWebcameraDriver::~DWebcameraDriver start"); |
94 Interrupt::Unbind(iIrq); |
91 CloseChunk(EWEBCAMERAINDEXADATABUF); |
95 DP("DWebcameraDriver::~DWebcameraDriver end"); |
92 Interrupt::Unbind(iIrq); |
96 } |
93 DP("DWebcameraDriver::~DWebcameraDriver end"); |
|
94 } |
97 |
95 |
98 TInt DWebcameraDriver::DoCreate(TInt aUnit, const TDesC8* anInfo) |
96 TInt DWebcameraDriver::DoCreate(TInt aUnit, const TDesC8* anInfo) |
99 { |
97 { |
100 DP("DWebcameraDriver::DoCreate start"); |
98 DP("DWebcameraDriver::DoCreate start"); |
101 iPortAddr=KHwSVPWebcameraDevice; |
99 iPortAddr = KHwSVPWebcameraDevice; |
102 iIrq = EIrqWebamera; |
100 iIrq = EIrqWebamera; |
103 Interrupt::Bind(iIrq,Isr,this); |
101 |
104 DP("DWebcameraDriver::DoCreate end"); |
102 Interrupt::Bind(iIrq, Isr, this); |
105 return KErrNone; |
103 DP("DWebcameraDriver::DoCreate end"); |
106 } |
104 return KErrNone; |
107 |
105 } |
108 TInt DWebcameraDriver::StartViewerFinder(TUint aBuffer,TInt aSize) |
106 |
109 { |
107 TInt DWebcameraDriver::PowerOn(TAny* aHeaderPtr) |
110 DP("DWebcameraDriver::StartViewerFinder start"); |
108 { |
111 iType=0; |
109 |
112 TUint32 temp=(TUint32)aBuffer; |
110 iClient = &Kern::CurrentThread(); |
113 DP("temp=%x",temp); |
111 ((DObject*)iClient)->Open(); |
114 DP("iPortAddr=%x",iPortAddr); |
112 |
115 WriteReg(iPortAddr,WEBCAMERA_REG_DATA_TYPE, 0x0); |
113 TInt ret = CreateChunk(sizeof(iDataInfo), EWEBCAMERAINDEXHAHEADERBUF); |
116 WriteReg(iPortAddr,WEBCAMERA_REG_DMA_ADDR,temp); |
114 WriteReg(iPortAddr, WEBCAMERA_REG_DMA_INFO, iPhysAddr[EWEBCAMERAINDEXHAHEADERBUF]); |
117 WriteReg(iPortAddr,WEBCAMERA_REG_DMA_SIZE, aSize); |
115 WriteReg(iPortAddr, WEBCAMERA_REG_DMA_INFOSIZE, sizeof(iDataInfo)); |
118 WriteReg(iPortAddr,WEBCAMERA_REG_INT_ENABLE, 0x1); |
116 WriteReg(iPortAddr, WEBCAMERA_REG_DMA_CONNECT,0x0); |
119 Interrupt::Enable(iIrq); |
117 |
120 |
118 kumemget(&iDataInfo, iChunk[EWEBCAMERAINDEXHAHEADERBUF]->Base(), sizeof(TWebcameraDataInfo)); |
121 DP("DWebcameraDriver::StartViewerFinder END"); |
119 |
122 return KErrNone; |
120 //Process(Transaction) that parse iDataInfo. |
123 } |
121 DWebCameraDescribe* bDescribe; |
124 |
122 bDescribe = new DWebCameraDescribe; |
125 TInt DWebcameraDriver::StartCapture(TUint aBuffer,TInt aSize) |
123 iUvcData = bDescribe->ParseDataInfo(iDataInfo); |
126 { |
124 delete bDescribe; |
127 DP("DWebcameraDriver::StartCapture start"); |
125 |
128 // Save a pointer to the buffer we need to put the 'recevied' data in |
126 //Store bUVC in TAny* aHeaderPtr. |
129 iType=1; |
127 kumemget(aHeaderPtr, &iUvcData, sizeof(TWebcameraUVC)); |
130 TUint32 temp=(TUint32)aBuffer; |
128 |
131 DP("temp=%x",temp); |
129 CloseChunk(EWEBCAMERAINDEXHAHEADERBUF); |
132 WriteReg(iPortAddr,WEBCAMERA_REG_DATA_TYPE, 0x1); |
130 |
133 WriteReg(iPortAddr,WEBCAMERA_REG_DMA_ADDR,temp); |
131 return ret; |
134 WriteReg(iPortAddr,WEBCAMERA_REG_DMA_SIZE, aSize); |
132 } |
135 WriteReg(iPortAddr,WEBCAMERA_REG_INT_ENABLE, 0x1); |
133 |
136 Interrupt::Enable(iIrq); |
134 TInt DWebcameraDriver::InitViewFinder() |
137 |
135 { |
138 DP("DWebcameraDriver::StartCapture END"); |
136 TInt ret = KErrNone; |
139 return KErrNone; |
137 |
140 } |
138 iClient = &Kern::CurrentThread(); |
|
139 ((DObject*)iClient)->Open(); |
|
140 ret = CreateChunk(BUFSIZE, EWEBCAMERAINDEXADATABUF); |
|
141 |
|
142 return ret; |
|
143 } |
|
144 |
|
145 TInt DWebcameraDriver::StartViewerFinder(TAny* aDataPtr, TInt aSize) |
|
146 { |
|
147 iType = 0; |
|
148 |
|
149 WriteReg(iPortAddr, WEBCAMERA_REG_DATA_TYPE, 0x0); |
|
150 WriteReg(iPortAddr, WEBCAMERA_REG_DMA_ADDR, iPhysAddr[EWEBCAMERAINDEXADATABUF]); |
|
151 WriteReg(iPortAddr, WEBCAMERA_REG_DMA_SIZE, aSize); |
|
152 WriteReg(iPortAddr, WEBCAMERA_REG_INT_ENABLE, 0x1); |
|
153 |
|
154 kumemget(aDataPtr, iChunk[EWEBCAMERAINDEXADATABUF]->Base(), aSize); |
|
155 |
|
156 Interrupt::Enable(iIrq); |
|
157 return KErrNone; |
|
158 } |
141 |
159 |
142 void DWebcameraDriver::Stop(TUSBStopMode aMode) |
160 void DWebcameraDriver::Stop(TUSBStopMode aMode) |
143 { |
161 { |
144 DP("DWebcameraDriver::Stop start"); |
162 WriteReg(iPortAddr, WEBCAMERA_REG_INT_ENABLE, 0x0); |
145 WriteReg(iPortAddr, WEBCAMERA_REG_INT_ENABLE, 0x0); |
163 Interrupt::Disable(iIrq); |
146 Interrupt::Disable(iIrq); |
164 } |
147 DP("DWebcameraDriver::Stop end"); |
165 |
148 } |
166 void DWebcameraDriver::Disconnect() |
|
167 { |
|
168 WriteReg(iPortAddr, WEBCAMERA_REG_DMA_DISCONNECT, 0x0); |
|
169 Interrupt::Disable(iIrq); |
|
170 } |
149 |
171 |
150 void DWebcameraDriver::Isr(TAny* aPtr) |
172 void DWebcameraDriver::Isr(TAny* aPtr) |
151 { |
173 { |
152 DP("DWebcameraDriver::Isr start"); |
174 ((DWebcameraDriver*)aPtr)->receivedatacallback(); |
153 ((DWebcameraDriver*)aPtr)->receivedatacallback(); |
175 } |
154 DP("DWebcameraDriver::Isr end"); |
|
155 } |
|
156 |
176 |
157 void DWebcameraDriver::receivedatacallback() |
177 void DWebcameraDriver::receivedatacallback() |
158 { |
178 { |
159 DP("DWebcameraDriver::receivedatacallback start"); |
179 TInt datasize = ReadReg(iPortAddr, WEBCAMERA_REG_DMA_SIZE); |
160 TInt datasize=ReadReg(iPortAddr,WEBCAMERA_REG_DMA_SIZE); |
180 switch (iType) |
161 switch (iType) |
181 { |
162 { |
182 case 0: |
163 case 0: |
183 iLdd->GetOneFlameComplete(datasize); |
164 iLdd->GetOneFlameComplete(datasize); |
184 break; |
165 break; |
185 default: |
166 case 1: |
186 DP("receivedatacallback error"); |
167 iLdd->CaptureComplete(datasize); |
187 break; |
168 break; |
188 } |
169 default: |
189 WriteReg(iPortAddr, WEBCAMERA_REG_DMA_ADDR, 0); |
170 // |
190 WriteReg(iPortAddr, WEBCAMERA_REG_DMA_SIZE, 0); |
171 } |
191 WriteReg(iPortAddr, WEBCAMERA_REG_INT_ENABLE, 0x0); |
172 WriteReg(iPortAddr,WEBCAMERA_REG_DMA_ADDR, 0); |
192 } |
173 WriteReg(iPortAddr,WEBCAMERA_REG_DMA_SIZE, 0); |
193 |
174 WriteReg(iPortAddr,WEBCAMERA_REG_INT_ENABLE, 0x0); |
194 /** |
175 DP("DWebcameraDriver::receivedatacallback end"); |
195 Chunk that used between PDD and USB. |
176 } |
196 */ |
177 |
197 TInt DWebcameraDriver::CreateChunk(TInt aSize, TWebcameraIndex aIndex) |
178 // --------------------------------------------------------------- |
198 { |
179 // --------------------------------------------------------------- |
199 TLinAddr wChunkLinAddr; |
|
200 TUint32 wChunkMappingAttr; |
|
201 RWebcameraDevice::TChunkInfo chunkInfo; |
|
202 |
|
203 TChunkCreateInfo info; |
|
204 info.iType = TChunkCreateInfo::ESharedKernelMultiple; |
|
205 info.iMaxSize = aSize; |
|
206 info.iMapAttr = EMapAttrFullyBlocking; |
|
207 info.iOwnsMemory = ETrue; |
|
208 info.iDestroyedDfc = NULL; |
|
209 |
|
210 //Chunk Create |
|
211 iChunk[aIndex] = NULL; |
|
212 iPhysAddr[aIndex] = 0x0; |
|
213 TInt ret = Kern::ChunkCreate(info, iChunk[aIndex], wChunkLinAddr, wChunkMappingAttr); |
|
214 if (ret != KErrNone) |
|
215 { |
|
216 DP("Kern::ChunkCreate Err = %d",ret); |
|
217 } |
|
218 ret = Kern::ChunkCommitContiguous(iChunk[aIndex], 0, aSize, iPhysAddr[aIndex]); |
|
219 if (ret != KErrNone) |
|
220 { |
|
221 DP("Kern::ChunkCommitContiguous Err = %d",ret); |
|
222 } |
|
223 |
|
224 //Chunk Open |
|
225 // Make handle to chunifo for current thread |
|
226 ret = Kern::MakeHandleAndOpen(iClient, iChunk[aIndex]); |
|
227 if (ret >= 0) |
|
228 { |
|
229 chunkInfo.iChunkHandle = ret; |
|
230 ret = KErrNone; |
|
231 } |
|
232 |
|
233 if (ret != KErrNone) |
|
234 { |
|
235 memclr(&chunkInfo, sizeof(chunkInfo)); |
|
236 } |
|
237 |
|
238 TInt result = Kern::ThreadRawWrite(iClient, &info, &chunkInfo, sizeof(chunkInfo), 0); |
|
239 if (result != KErrNone) |
|
240 { |
|
241 DP("Kern::ChunkCommitContiguous Err = %d",result); |
|
242 } |
|
243 return KErrNone; |
|
244 } |
|
245 |
|
246 void DWebcameraDriver::CloseChunk(TWebcameraIndex aIndex) |
|
247 { |
|
248 Kern::ChunkClose(iChunk[aIndex]); |
|
249 Kern::SafeClose((DObject*&)iClient, NULL); |
|
250 } |
180 |
251 |
181 DECLARE_STANDARD_PDD() |
252 DECLARE_STANDARD_PDD() |
182 { |
253 { |
183 DP("DECLARE_STANDARD_PDD()"); |
254 DP("DECLARE_STANDARD_PDD()"); |
184 return new DWebcameraPddFactory; |
255 return new DWebcameraPddFactory; |
185 } |
256 } |
186 |
|