99 CUsbACMClassController::CUsbACMClassController( |
101 CUsbACMClassController::CUsbACMClassController( |
100 MUsbClassControllerNotify& aOwner) |
102 MUsbClassControllerNotify& aOwner) |
101 : CUsbClassControllerPlugIn(aOwner, KAcmStartupPriority), |
103 : CUsbClassControllerPlugIn(aOwner, KAcmStartupPriority), |
102 iNumberOfAcmFunctions(KDefaultNumberOfAcmFunctions) |
104 iNumberOfAcmFunctions(KDefaultNumberOfAcmFunctions) |
103 { |
105 { |
|
106 OstTraceFunctionEntry0( CUSBACMCLASSCONTROLLER_CUSBACMCLASSCONTROLLER_CONS_ENTRY ); |
|
107 OstTraceFunctionExit0( CUSBACMCLASSCONTROLLER_CUSBACMCLASSCONTROLLER_CONS_EXIT ); |
104 } |
108 } |
105 |
109 |
106 /** |
110 /** |
107 * 2nd Phase Construction. |
111 * 2nd Phase Construction. |
108 */ |
112 */ |
109 void CUsbACMClassController::ConstructL() |
113 void CUsbACMClassController::ConstructL() |
110 { |
114 { |
|
115 OstTraceFunctionEntry0( CUSBACMCLASSCONTROLLER_CONSTRUCTL_ENTRY ); |
|
116 |
111 iNumberOfAcmFunctions = KUsbAcmNumberOfAcmFunctions; |
117 iNumberOfAcmFunctions = KUsbAcmNumberOfAcmFunctions; |
112 |
118 |
113 iAcmProtocolNum[0] = KUsbAcmProtocolNumAcm1; |
119 iAcmProtocolNum[0] = KUsbAcmProtocolNumAcm1; |
114 iAcmProtocolNum[1] = KUsbAcmProtocolNumAcm2; |
120 iAcmProtocolNum[1] = KUsbAcmProtocolNumAcm2; |
115 iAcmProtocolNum[2] = KUsbAcmProtocolNumAcm3; |
121 iAcmProtocolNum[2] = KUsbAcmProtocolNumAcm3; |
116 iAcmProtocolNum[3] = KUsbAcmProtocolNumAcm4; |
122 iAcmProtocolNum[3] = KUsbAcmProtocolNumAcm4; |
117 iAcmProtocolNum[4] = KUsbAcmProtocolNumAcm5; |
123 iAcmProtocolNum[4] = KUsbAcmProtocolNumAcm5; |
118 |
124 |
119 // Prepare to use whichever mechanism is enabled to control bringing ACM |
125 // Prepare to use whichever mechanism is enabled to control bringing ACM |
120 // functions up and down. |
126 // functions up and down. |
|
127 TInt err; |
121 #ifdef USE_ACM_REGISTRATION_PORT |
128 #ifdef USE_ACM_REGISTRATION_PORT |
122 |
129 |
123 LEAVEIFERRORL(iCommServer.Connect()); |
130 err = iCommServer.Connect(); |
124 LEAVEIFERRORL(iCommServer.LoadCommModule(KAcmCsyName)); |
131 if (err < 0) |
|
132 { |
|
133 OstTrace1( TRACE_ERROR, CUSBACMCLASSCONTROLLER_CONSTRUCTL, "CUsbACMClassController::ConstructL;leave err=%d", err ); |
|
134 User::Leave(err); |
|
135 } |
|
136 |
|
137 err = iCommServer.LoadCommModule(KAcmCsyName); |
|
138 if (err < 0) |
|
139 { |
|
140 OstTrace1( TRACE_ERROR, CUSBACMCLASSCONTROLLER_CONSTRUCTL_DUP1, "CUsbACMClassController::ConstructL;leave err=%d", err ); |
|
141 User::Leave(err); |
|
142 } |
|
143 |
125 TName portName(KAcmSerialName); |
144 TName portName(KAcmSerialName); |
126 portName.AppendFormat(_L("::%d"), 666); |
145 portName.AppendFormat(_L("::%d"), 666); |
127 // Open the registration port in shared mode in case other ACM CCs want to |
146 // Open the registration port in shared mode in case other ACM CCs want to |
128 // open it. |
147 // open it. |
129 LEAVEIFERRORL(iComm.Open(iCommServer, portName, ECommShared)); |
148 err = iComm.Open(iCommServer, portName, ECommShared); |
|
149 if (err < 0) |
|
150 { |
|
151 OstTrace1( TRACE_ERROR, CUSBACMCLASSCONTROLLER_CONSTRUCTL_DUP2, "CUsbACMClassController::ConstructL;leave err=%d", err ); |
|
152 User::Leave(err); |
|
153 } |
130 |
154 |
131 #else |
155 #else |
132 |
156 |
133 LEAVEIFERRORL(iAcmServer.Connect()); |
157 err = iAcmServer.Connect(); |
|
158 if (err < 0) |
|
159 { |
|
160 OstTrace1( TRACE_ERROR, CUSBACMCLASSCONTROLLER_CONSTRUCTL_DUP3, "CUsbACMClassController::ConstructL;leave err=%d", err ); |
|
161 User::Leave(err); |
|
162 } |
134 |
163 |
135 #endif // USE_ACM_REGISTRATION_PORT |
164 #endif // USE_ACM_REGISTRATION_PORT |
|
165 OstTraceFunctionExit0( CUSBACMCLASSCONTROLLER_CONSTRUCTL_EXIT ); |
136 } |
166 } |
137 |
167 |
138 /** |
168 /** |
139 * Called by UsbMan when it wants to start the USB ACM class. This always |
169 * Called by UsbMan when it wants to start the USB ACM class. This always |
140 * completes immediately. |
170 * completes immediately. |
141 * |
171 * |
142 * @param aStatus The caller's request status, filled in with an error code |
172 * @param aStatus The caller's request status, filled in with an error code |
143 */ |
173 */ |
144 void CUsbACMClassController::Start(TRequestStatus& aStatus) |
174 void CUsbACMClassController::Start(TRequestStatus& aStatus) |
145 { |
175 { |
146 LOG_FUNC; |
176 OstTraceFunctionEntry0( CUSBACMCLASSCONTROLLER_START_ENTRY ); |
147 |
177 |
148 // We should always be idle when this function is called (guaranteed by |
178 // We should always be idle when this function is called (guaranteed by |
149 // CUsbSession). |
179 // CUsbSession). |
150 __ASSERT_DEBUG( iState == EUsbServiceIdle, _USB_PANIC(KAcmCcPanicCategory, EBadApiCallStart) ); |
180 if (iState != EUsbServiceIdle) |
|
181 { |
|
182 OstTrace1( TRACE_FATAL, CUSBACMCLASSCONTROLLER_START, "CUsbACMClassController::Start;iState=%d", (TInt)iState ); |
|
183 __ASSERT_DEBUG( EFalse, User::Panic(KAcmCcPanicCategory, EBadApiCallStart) ); |
|
184 } |
151 |
185 |
152 TRequestStatus* reportStatus = &aStatus; |
186 TRequestStatus* reportStatus = &aStatus; |
153 TRAPD(err, DoStartL()); |
187 TRAPD(err, DoStartL()); |
154 iState = (err == KErrNone) ? EUsbServiceStarted : EUsbServiceIdle; |
188 iState = (err == KErrNone) ? EUsbServiceStarted : EUsbServiceIdle; |
155 User::RequestComplete(reportStatus, err); |
189 User::RequestComplete(reportStatus, err); |
|
190 OstTraceFunctionExit0( CUSBACMCLASSCONTROLLER_START_EXIT ); |
156 } |
191 } |
157 |
192 |
158 void CUsbACMClassController::DoStartL() |
193 void CUsbACMClassController::DoStartL() |
159 { |
194 { |
160 LOG_FUNC |
195 OstTraceFunctionEntry0( CUSBACMCLASSCONTROLLER_DOSTARTL_ENTRY ); |
|
196 |
161 |
197 |
162 iState = EUsbServiceStarting; |
198 iState = EUsbServiceStarting; |
163 LOGTEXT2(_L8(" iNumberOfAcmFunctions = %d"), iNumberOfAcmFunctions); |
199 OstTrace1( TRACE_NORMAL, CUSBACMCLASSCONTROLLER_DOSTARTL, "CUsbACMClassController::DoStartL;iNumberOfAcmFunctions=%d", iNumberOfAcmFunctions ); |
164 |
200 |
165 #ifdef USE_ACM_REGISTRATION_PORT |
201 #ifdef USE_ACM_REGISTRATION_PORT |
166 |
202 |
167 // Create ACM functions. |
203 // Create ACM functions. |
168 TUint acmSetting; |
204 TUint acmSetting; |
169 for (TUint i = 0; i < iNumberOfAcmFunctions; i++) |
205 for (TUint i = 0; i < iNumberOfAcmFunctions; i++) |
170 { |
206 { |
171 LOGTEXT2(_L8(" iAcmProtocolNum[i] = %d"), iAcmProtocolNum[i]); |
207 OstTrace1( TRACE_NORMAL, CUSBACMCLASSCONTROLLER_DOSTARTL_DUP1, "CUsbACMClassController::DoStartL;iAcmProtocolNum[i]=%u", iAcmProtocolNum[i] ); |
172 |
208 |
173 // indicate the number of ACMs to create, and its protocol number (in the 3rd-lowest byte) |
209 // indicate the number of ACMs to create, and its protocol number (in the 3rd-lowest byte) |
174 acmSetting = 1 | (static_cast<TUint> (iAcmProtocolNum[i]) << 16); |
210 acmSetting = 1 | (static_cast<TUint> (iAcmProtocolNum[i]) << 16); |
175 TInt err = iComm.SetSignalsToMark(acmSetting); |
211 TInt err = iComm.SetSignalsToMark(acmSetting); |
176 if (err != KErrNone) |
212 if (err != KErrNone) |
177 { |
213 { |
178 LOGTEXT2(_L8(" SetSignalsToMark error = %d"), err); |
214 OstTrace1( TRACE_NORMAL, CUSBACMCLASSCONTROLLER_DOSTARTL_DUP2, "CUsbACMClassController::DoStartL;SetSignalsToMark error = %d", err ); |
179 if (i != 0) |
215 if (i != 0) |
180 { |
216 { |
181 // Must clear any ACMs that have completed. |
217 // Must clear any ACMs that have completed. |
182 // only other than KErrNone if C32 Server fails |
218 // only other than KErrNone if C32 Server fails |
183 (void) iComm.SetSignalsToSpace(i); |
219 (void) iComm.SetSignalsToSpace(i); |
184 } |
220 } |
185 LEAVEL(err); |
221 OstTrace1( TRACE_ERROR, CUSBACMCLASSCONTROLLER_DOSTARTL_DUP6, "CUsbACMClassController::DoStartL;leave err=%d", err ); |
|
222 User::Leave(err); |
186 } |
223 } |
187 } |
224 } |
188 |
225 |
189 #else // use ACM server |
226 #else // use ACM server |
190 // Create ACM functions |
227 // Create ACM functions |
196 //is not supported now. |
233 //is not supported now. |
197 err = iAcmServer.CreateFunctions(1, iAcmProtocolNum[i], KControlIfcName, KDataIfcName); |
234 err = iAcmServer.CreateFunctions(1, iAcmProtocolNum[i], KControlIfcName, KDataIfcName); |
198 |
235 |
199 if ( err != KErrNone ) |
236 if ( err != KErrNone ) |
200 { |
237 { |
201 LOGTEXT2(_L8("\tFailed to create ACM function. Error: %d"), err); |
238 OstTrace1( TRACE_NORMAL, CUSBACMCLASSCONTROLLER_DOSTARTL_DUP3, "CUsbACMClassController::DoStartL;\tFailed to create ACM function. Error: %d", err); |
|
239 |
202 if (i != 0) |
240 if (i != 0) |
203 { |
241 { |
204 //Must clear any ACMs that have been completed |
242 //Must clear any ACMs that have been completed |
205 iAcmServer.DestroyFunctions(i); |
243 iAcmServer.DestroyFunctions(i); |
206 LOGTEXT2(_L8("\tDestroyed %d Interfaces"), i); |
244 OstTrace1( TRACE_NORMAL, CUSBACMCLASSCONTROLLER_DOSTARTL_DUP4, "CUsbACMClassController::DoStartL;\tDestroyed %d Interfaces", i ); |
207 } |
245 } |
208 LEAVEL(err); |
246 OstTrace1( TRACE_NORMAL, CUSBACMCLASSCONTROLLER_DOSTARTL_DUP7, "CUsbACMClassController::DoStartL; leave Error: %d", err); |
|
247 User::Leave(err); |
209 } |
248 } |
210 } |
249 } |
211 |
250 |
212 #endif // USE_ACM_REGISTRATION_PORT |
251 #endif // USE_ACM_REGISTRATION_PORT |
213 |
252 |
214 LOGTEXT2(_L8("\tCreated %d ACM Interfaces"), iNumberOfAcmFunctions); |
253 OstTrace1( TRACE_NORMAL, CUSBACMCLASSCONTROLLER_DOSTARTL_DUP5, "CUsbACMClassController::DoStartL;\tCreated %d ACM Interfaces", iNumberOfAcmFunctions ); |
|
254 OstTraceFunctionExit0( CUSBACMCLASSCONTROLLER_DOSTARTL_EXIT ); |
215 } |
255 } |
216 |
256 |
217 /** |
257 /** |
218 * Called by UsbMan when it wants to stop the USB ACM class. |
258 * Called by UsbMan when it wants to stop the USB ACM class. |
219 * |
259 * |
220 * @param aStatus The caller's request status: always set to KErrNone |
260 * @param aStatus The caller's request status: always set to KErrNone |
221 */ |
261 */ |
222 void CUsbACMClassController::Stop(TRequestStatus& aStatus) |
262 void CUsbACMClassController::Stop(TRequestStatus& aStatus) |
223 { |
263 { |
224 LOG_FUNC; |
264 OstTraceFunctionEntry0( CUSBACMCLASSCONTROLLER_STOP_ENTRY ); |
225 |
265 |
226 // We should always be started when this function is called (guaranteed by |
266 // We should always be started when this function is called (guaranteed by |
227 // CUsbSession). |
267 // CUsbSession). |
228 __ASSERT_DEBUG( iState == EUsbServiceStarted, _USB_PANIC(KAcmCcPanicCategory, EBadApiCallStop) ); |
268 //User::Panic(KAcmCcPanicCategory, EBadApiCallStop); |
|
269 if (iState != EUsbServiceStarted) |
|
270 { |
|
271 OstTrace1( TRACE_FATAL, CUSBACMCLASSCONTROLLER_STOP, "CUsbACMClassController::Stop;iState=%d", (TInt)iState ); |
|
272 __ASSERT_DEBUG( EFalse, User::Panic(KAcmCcPanicCategory, EBadApiCallStop) ); |
|
273 } |
229 |
274 |
230 TRequestStatus* reportStatus = &aStatus; |
275 TRequestStatus* reportStatus = &aStatus; |
231 DoStop(); |
276 DoStop(); |
232 User::RequestComplete(reportStatus, KErrNone); |
277 User::RequestComplete(reportStatus, KErrNone); |
|
278 OstTraceFunctionExit0( CUSBACMCLASSCONTROLLER_STOP_EXIT ); |
233 } |
279 } |
234 |
280 |
235 /** |
281 /** |
236 * Gets information about the descriptor which this class provides. |
282 * Gets information about the descriptor which this class provides. |
237 * |
283 * |
238 * @param aDescriptorInfo Descriptor info structure filled in by this function |
284 * @param aDescriptorInfo Descriptor info structure filled in by this function |
239 */ |
285 */ |
240 void CUsbACMClassController::GetDescriptorInfo(TUsbDescriptor& aDescriptorInfo) const |
286 void CUsbACMClassController::GetDescriptorInfo(TUsbDescriptor& aDescriptorInfo) const |
241 { |
287 { |
242 LOG_FUNC; |
288 OstTraceFunctionEntry0( CUSBACMCLASSCONTROLLER_GETDESCRIPTORINFO_ENTRY ); |
243 |
|
244 aDescriptorInfo.iLength = KAcmDescriptorLength; |
289 aDescriptorInfo.iLength = KAcmDescriptorLength; |
245 aDescriptorInfo.iNumInterfaces = KAcmNumberOfInterfacesPerAcmFunction*(iNumberOfAcmFunctions); |
290 aDescriptorInfo.iNumInterfaces = KAcmNumberOfInterfacesPerAcmFunction*(iNumberOfAcmFunctions); |
|
291 OstTraceFunctionExit0( CUSBACMCLASSCONTROLLER_GETDESCRIPTORINFO_EXIT ); |
246 } |
292 } |
247 |
293 |
248 /** |
294 /** |
249 Destroys ACM functions we've already brought up. |
295 Destroys ACM functions we've already brought up. |
250 */ |
296 */ |
251 void CUsbACMClassController::DoStop() |
297 void CUsbACMClassController::DoStop() |
252 { |
298 { |
253 LOG_FUNC; |
299 OstTraceFunctionEntry0( CUSBACMCLASSCONTROLLER_DOSTOP_ENTRY ); |
254 |
|
255 if (iState == EUsbServiceStarted) |
300 if (iState == EUsbServiceStarted) |
256 { |
301 { |
257 #ifdef USE_ACM_REGISTRATION_PORT |
302 #ifdef USE_ACM_REGISTRATION_PORT |
258 TInt err = iComm.SetSignalsToSpace(iNumberOfAcmFunctions); |
303 TInt err = iComm.SetSignalsToSpace(iNumberOfAcmFunctions); |
259 __ASSERT_DEBUG(err == KErrNone, User::Invariant()); |
304 if (err != KErrNone) |
|
305 { |
|
306 OstTrace1( TRACE_FATAL, CUSBACMCLASSCONTROLLER_DOSTOP_DUP1, "CUsbACMClassController::DoStop;err=%d", err ); |
|
307 User::Invariant(); |
|
308 } |
260 //the implementation in CRegistrationPort always return KErrNone |
309 //the implementation in CRegistrationPort always return KErrNone |
261 (void)err; |
310 (void)err; |
262 // If there is an error here, USBSVR will just ignore it, but |
311 // If there is an error here, USBSVR will just ignore it, but |
263 // it indicates that our interfaces are still up. We know the CSY |
312 // it indicates that our interfaces are still up. We know the CSY |
264 // doesn't raise an error, but an IPC error may have occurred. This is |
313 // doesn't raise an error, but an IPC error may have occurred. This is |
266 // work. |
315 // work. |
267 #else |
316 #else |
268 // Destroy interfaces. Can't do anything with an error here. |
317 // Destroy interfaces. Can't do anything with an error here. |
269 static_cast<void>(iAcmServer.DestroyFunctions(iNumberOfAcmFunctions)); |
318 static_cast<void>(iAcmServer.DestroyFunctions(iNumberOfAcmFunctions)); |
270 #endif // USE_ACM_REGISTRATION_PORT |
319 #endif // USE_ACM_REGISTRATION_PORT |
271 |
320 OstTrace1( TRACE_NORMAL, CUSBACMCLASSCONTROLLER_DOSTOP, "CUsbACMClassController::DoStop;\tDestroyed %d Interfaces", iNumberOfAcmFunctions ); |
272 LOGTEXT2(_L8("\tDestroyed %d Interfaces"), iNumberOfAcmFunctions); |
|
273 |
|
274 iState = EUsbServiceIdle; |
321 iState = EUsbServiceIdle; |
275 } |
322 } |
|
323 OstTraceFunctionExit0( CUSBACMCLASSCONTROLLER_DOSTOP_EXIT ); |
276 } |
324 } |
277 |
325 |
278 /** |
326 /** |
279 * Standard active object RunL. Never called because this class has no |
327 * Standard active object RunL. Never called because this class has no |
280 * asynchronous requests. |
328 * asynchronous requests. |
281 */ |
329 */ |
282 void CUsbACMClassController::RunL() |
330 void CUsbACMClassController::RunL() |
283 { |
331 { |
284 __ASSERT_DEBUG( EFalse, _USB_PANIC(KAcmCcPanicCategory, EUnusedFunction) ); |
332 OstTraceFunctionEntry0( CUSBACMCLASSCONTROLLER_RUNL_ENTRY ); |
|
333 OstTrace0( TRACE_FATAL, CUSBACMCLASSCONTROLLER_RUNL, "CUsbACMClassController::RunL;EUnusedFunction" ); |
|
334 __ASSERT_DEBUG( EFalse, User::Panic(KAcmCcPanicCategory, EUnusedFunction) ); |
|
335 OstTraceFunctionExit0( CUSBACMCLASSCONTROLLER_RUNL_EXIT ); |
285 } |
336 } |
286 |
337 |
287 /** |
338 /** |
288 * Standard active object cancellation function. Never called because this |
339 * Standard active object cancellation function. Never called because this |
289 * class has no asynchronous requests. |
340 * class has no asynchronous requests. |
290 */ |
341 */ |
291 void CUsbACMClassController::DoCancel() |
342 void CUsbACMClassController::DoCancel() |
292 { |
343 { |
293 __ASSERT_DEBUG( EFalse, _USB_PANIC(KAcmCcPanicCategory, EUnusedFunction) ); |
344 OstTraceFunctionEntry0( CUSBACMCLASSCONTROLLER_DOCANCEL_ENTRY ); |
|
345 OstTrace0( TRACE_FATAL, CUSBACMCLASSCONTROLLER_DOCANCEL, "CUsbACMClassController::DoCancel;EUnusedFunction" ); |
|
346 __ASSERT_DEBUG( EFalse, User::Panic(KAcmCcPanicCategory, EUnusedFunction) ); |
|
347 OstTraceFunctionExit0( CUSBACMCLASSCONTROLLER_DOCANCEL_EXIT ); |
294 } |
348 } |
295 |
349 |
296 /** |
350 /** |
297 * Standard active object error function. Never called because this class has |
351 * Standard active object error function. Never called because this class has |
298 * no asynchronous requests, and hence its RunL is never called. |
352 * no asynchronous requests, and hence its RunL is never called. |