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