1 /*
2 ********************************************************************************************************************
3 * usb host driver
4 *
5 * (c) Copyright 2007-2010, javen.China
6 * All Rights Reserved
7 *
8 * File Name : usb_msc.c
9 *
10 * Author : javen
11 *
12 * Version : 2.0
13 *
14 * Date : 2010.03.02
15 *
16 * Description :
17 *
18 * History :
19 *
20 ********************************************************************************************************************
21 */
22 #include "usb_os_platform.h"
23 #include "error.h"
24
25 #include "usb_utils_find_zero_bit.h"
26 #include "usb_list.h"
27 #include "list_head_ext.h"
28
29 #include "usb_host_common.h"
30 #include "usb_gen_dev_mod.h"
31 #include "urb.h"
32 #include "usb_core_interface.h"
33
34 #include "usbh_disk_info.h"
35 #include "usbh_buff_manager.h"
36 #include "usbh_disk_remove_time.h"
37
38 #include "usb_msc_i.h"
39 #include "mscTransport.h"
40 #include "mscProtocol.h"
41 #include "LunMgr.h"
42 #include "usb_msc.h"
43
44 #define MSC_DRV_NAME "Mass Storage Class"
45 #define MSC_DRV_AUTHOR "Host Driver Author"
46
47 static struct usb_host_func_drv mscDrv; /* 存储USB Mass Storage设备驱动 */
48 static __u32 mscDev_id_array; /* 记录已连接的mscDev的id值 */
49
50 static struct usb_drv_dev_match_table msc_match_table [] =
51 {
52 //--1--CB
53 {
54 USB_DEVICE_ID_MATCH_INT_INFO //match_flags;
55 , 0, 0, 0, 0, 0, 0, 0
56 //bInterfaceClass;bInterfaceSubClass;bInterfaceProtocol
57 , USB_CLASS_MASS_STORAGE
58 , USBMSC_SUBCLASS_RBC
59 , USBMSC_INTERFACE_PROTOCOL_CBT
60 , 0 //driver_info;
61 },
62 {
63 USB_DEVICE_ID_MATCH_INT_INFO //match_flags;
64 , 0, 0, 0, 0, 0, 0, 0
65 //bInterfaceClass;bInterfaceSubClass;bInterfaceProtocol
66 , USB_CLASS_MASS_STORAGE
67 , USBMSC_SUBCLASS_8020
68 , USBMSC_INTERFACE_PROTOCOL_CBT
69 , 0 //driver_info;
70 },
71 {
72 USB_DEVICE_ID_MATCH_INT_INFO //match_flags;
73 , 0, 0, 0, 0, 0, 0, 0
74 //bInterfaceClass;bInterfaceSubClass;bInterfaceProtocol
75 , USB_CLASS_MASS_STORAGE
76 , USBMSC_SUBCLASS_QIC
77 , USBMSC_INTERFACE_PROTOCOL_CBT
78 , 0 //driver_info;
79 },
80
81 {
82 USB_DEVICE_ID_MATCH_INT_INFO //match_flags;
83 , 0, 0, 0, 0, 0, 0, 0
84 //bInterfaceClass;bInterfaceSubClass;bInterfaceProtocol
85 , USB_CLASS_MASS_STORAGE
86 , USBMSC_SUBCLASS_UFI
87 , USBMSC_INTERFACE_PROTOCOL_CBT
88 , 0 //driver_info;
89 },
90 {
91 USB_DEVICE_ID_MATCH_INT_INFO //match_flags;
92 , 0, 0, 0, 0, 0, 0, 0
93 //bInterfaceClass;bInterfaceSubClass;bInterfaceProtocol
94 , USB_CLASS_MASS_STORAGE
95 , USBMSC_SUBCLASS_8070
96 , USBMSC_INTERFACE_PROTOCOL_CBT
97 , 0 //driver_info;
98 },
99 {
100 USB_DEVICE_ID_MATCH_INT_INFO //match_flags;
101 , 0, 0, 0, 0, 0, 0, 0
102 //bInterfaceClass;bInterfaceSubClass;bInterfaceProtocol
103 , USB_CLASS_MASS_STORAGE
104 , USBMSC_SUBCLASS_SCSI
105 , USBMSC_INTERFACE_PROTOCOL_CBT
106 , 0 //driver_info;
107 },
108 //--2--CBI
109 {
110 USB_DEVICE_ID_MATCH_INT_INFO //match_flags;
111 , 0, 0, 0, 0, 0, 0, 0
112 //bInterfaceClass;bInterfaceSubClass;bInterfaceProtocol
113 , USB_CLASS_MASS_STORAGE
114 , USBMSC_SUBCLASS_RBC
115 , USBMSC_INTERFACE_PROTOCOL_CBIT
116 , 0 //driver_info;
117 },
118 {
119 USB_DEVICE_ID_MATCH_INT_INFO //match_flags;
120 , 0, 0, 0, 0, 0, 0, 0
121 //bInterfaceClass;bInterfaceSubClass;bInterfaceProtocol
122 , USB_CLASS_MASS_STORAGE
123 , USBMSC_SUBCLASS_8020
124 , USBMSC_INTERFACE_PROTOCOL_CBIT
125 , 0 //driver_info;
126 },
127 {
128 USB_DEVICE_ID_MATCH_INT_INFO //match_flags;
129 , 0, 0, 0, 0, 0, 0, 0
130 //bInterfaceClass;bInterfaceSubClass;bInterfaceProtocol
131 , USB_CLASS_MASS_STORAGE
132 , USBMSC_SUBCLASS_QIC
133 , USBMSC_INTERFACE_PROTOCOL_CBIT
134 , 0 //driver_info;
135 },
136
137 {
138 USB_DEVICE_ID_MATCH_INT_INFO //match_flags;
139 , 0, 0, 0, 0, 0, 0, 0
140 //bInterfaceClass;bInterfaceSubClass;bInterfaceProtocol
141 , USB_CLASS_MASS_STORAGE
142 , USBMSC_SUBCLASS_UFI
143 , USBMSC_INTERFACE_PROTOCOL_CBIT
144 , 0 //driver_info;
145 },
146 {
147 USB_DEVICE_ID_MATCH_INT_INFO //match_flags;
148 , 0, 0, 0, 0, 0, 0, 0
149 //bInterfaceClass;bInterfaceSubClass;bInterfaceProtocol
150 , USB_CLASS_MASS_STORAGE
151 , USBMSC_SUBCLASS_8070
152 , USBMSC_INTERFACE_PROTOCOL_CBIT
153 , 0 //driver_info;
154 },
155 {
156 USB_DEVICE_ID_MATCH_INT_INFO //match_flags;
157 , 0, 0, 0, 0, 0, 0, 0
158 //bInterfaceClass;bInterfaceSubClass;bInterfaceProtocol
159 , USB_CLASS_MASS_STORAGE
160 , USBMSC_SUBCLASS_SCSI
161 , USBMSC_INTERFACE_PROTOCOL_CBIT
162 , 0 //driver_info;
163 },
164 //--3--BO
165 {
166 USB_DEVICE_ID_MATCH_INT_INFO //match_flags;
167 , 0, 0, 0, 0, 0, 0, 0
168 //bInterfaceClass;bInterfaceSubClass;bInterfaceProtocol
169 , USB_CLASS_MASS_STORAGE
170 , USBMSC_SUBCLASS_RBC
171 , USBMSC_INTERFACE_PROTOCOL_BOT
172 , 0 //driver_info;
173 },
174 {
175 USB_DEVICE_ID_MATCH_INT_INFO //match_flags;
176 , 0, 0, 0, 0, 0, 0, 0
177 //bInterfaceClass;bInterfaceSubClass;bInterfaceProtocol
178 , USB_CLASS_MASS_STORAGE
179 , USBMSC_SUBCLASS_8020
180 , USBMSC_INTERFACE_PROTOCOL_BOT
181 , 0 //driver_info;
182 },
183 {
184 USB_DEVICE_ID_MATCH_INT_INFO //match_flags;
185 , 0, 0, 0, 0, 0, 0, 0
186 //bInterfaceClass;bInterfaceSubClass;bInterfaceProtocol
187 , USB_CLASS_MASS_STORAGE
188 , USBMSC_SUBCLASS_QIC
189 , USBMSC_INTERFACE_PROTOCOL_BOT
190 , 0 //driver_info;
191 },
192
193 {
194 USB_DEVICE_ID_MATCH_INT_INFO //match_flags;
195 , 0, 0, 0, 0, 0, 0, 0
196 //bInterfaceClass;bInterfaceSubClass;bInterfaceProtocol
197 , USB_CLASS_MASS_STORAGE
198 , USBMSC_SUBCLASS_UFI
199 , USBMSC_INTERFACE_PROTOCOL_BOT
200 , 0 //driver_info;
201 },
202 {
203 USB_DEVICE_ID_MATCH_INT_INFO //match_flags;
204 , 0, 0, 0, 0, 0, 0, 0
205 //bInterfaceClass;bInterfaceSubClass;bInterfaceProtocol
206 , USB_CLASS_MASS_STORAGE
207 , USBMSC_SUBCLASS_8070
208 , USBMSC_INTERFACE_PROTOCOL_BOT
209 , 0 //driver_info;
210 },
211 {
212 USB_DEVICE_ID_MATCH_INT_INFO //match_flags;
213 , 0, 0, 0, 0, 0, 0, 0
214 //bInterfaceClass;bInterfaceSubClass;bInterfaceProtocol
215 , USB_CLASS_MASS_STORAGE
216 , USBMSC_SUBCLASS_SCSI
217 , USBMSC_INTERFACE_PROTOCOL_BOT
218 , 0 //driver_info;
219 },
220 {
221 0
222 , 0, 0, 0, 0, 0, 0, 0
223 , 0
224 , 0
225 , 0
226
227 , 0
228 },
229
230 {
231 0 //match_flags;
232
233 , 0 //idVendor;
234 , 0 //idProduct;
235 , 0 //bcdDevice_lo;
236 , 0 //bcdDevice_hi;
237
238 //Used for device class matches
239 , 0 //bDeviceClass;
240 , 0 //bDeviceSubClass;
241 , 0 //bDeviceProtocol;
242
243 //Used for interface class matches
244 , 0 //bInterfaceClass;
245 , 0 //bInterfaceSubClass;
246 , 0 //bInterfaceProtocol;
247
248 //not matched against
249 , 0 //driver_info;
250 }/* Terminating entry */
251 };
252
253 /*
254 *******************************************************************************
255 * get_mscDev_id
256 *
257 * Description:
258 * 获取USB Mass Storage设备的ID
259 *
260 * Parameters:
261 * void
262 *
263 * Return value:
264 * 返回设备的ID
265 *
266 * note:
267 * 无
268 *
269 *******************************************************************************
270 */
get_mscDev_id(void)271 static unsigned int get_mscDev_id(void)
272 {
273 unsigned int bit = 0;
274 bit = find_next_zero_bit((const volatile u32 *)&mscDev_id_array, (1 * 32), 0);
275
276 if (bit > 32)
277 {
278 hal_log_err("ERR: find_next_zero_bit failed");
279 return 31;
280 }
281
282 usb_set_bit(bit, (volatile uint32_t *)&mscDev_id_array);
283 return bit;
284 }
285
286 /*
287 *******************************************************************************
288 * free_mscDev_id
289 *
290 * Description:
291 * 释放USB Mass Storage设备的ID
292 *
293 * Parameters:
294 * bit : input. mscDev的ID号
295 *
296 * Return value:
297 * 0 成功
298 * !0 失败
299 *
300 * note:
301 * 无
302 *
303 *******************************************************************************
304 */
free_mscDev_id(unsigned int bit)305 static int free_mscDev_id(unsigned int bit)
306 {
307 if (usb_test_bit(bit, (volatile uint32_t *)&mscDev_id_array) == 0)
308 {
309 hal_log_err("ERR: free_mscDev_id: invalid bit(%d)", bit);
310 return -1;
311 }
312
313 /* 释放占用位 */
314 usb_clear_bit(bit, (volatile uint32_t *)&mscDev_id_array);
315 return 0;
316 }
317
318
319 /*
320 *******************************************************************************
321 * mscDevInit
322 *
323 * Description:
324 *
325 *
326 * Parameters:
327 * mscDev : input. msc设备信息
328 * intf : input. USB接口
329 *
330 * Return value:
331 * 0 成功
332 * !0 失败
333 *
334 * note:
335 * 无
336 *
337 *******************************************************************************
338 */
339
mscDevInit(__mscDev_t * mscDev,struct usb_interface * intf)340 static int mscDevInit(__mscDev_t *mscDev, struct usb_interface *intf)
341 {
342 int ret = 0;
343 __u8 err = 0;
344
345 if (mscDev == NULL)
346 {
347 hal_log_err("ERR: invalid argment");
348 return -1;
349 }
350
351 mscDev->pusb_dev = usb_mod_interface_to_usbdev(intf);
352
353 if (mscDev->pusb_dev == NULL)
354 {
355 hal_log_err("ERR: invalid argment");
356 return -1;
357 }
358
359 mscDev->pusb_intf = intf;
360 mscDev->InterfaceNo = intf->cur_altsetting->desc.bInterfaceNumber;
361 /* Store our private data in the interface */
362 usb_mod_usb_set_intf_priv_data(intf, (void *)mscDev);
363 mscDev->mscDevNo = get_mscDev_id();
364 USB_INIT_LIST_HEAD(&(mscDev->cmd_list));
365 /* alloc urb */
366 mscDev->CurrentUrb = usb_alloc_urb(0);
367
368 if (mscDev->CurrentUrb == NULL)
369 {
370 hal_log_err("ERR: hal_sem_create scan_lock failed");
371 return USB_ERR_ALLOC_URB_FAILED;
372 }
373
374 /* 一次性锁 */
375 mscDev->scan_lock = hal_sem_create(1);
376
377 if (mscDev->scan_lock == NULL)
378 {
379 hal_log_err("ERR: hal_sem_create scan_lock failed");
380 ret = USB_ERR_CREATE_SIME_FAILED;
381 goto error0;
382 }
383
384 mscDev->DevLock = hal_sem_create(1);
385
386 if (mscDev->DevLock == NULL)
387 {
388 hal_log_err("ERR: hal_sem_create DevLock failed");
389 ret = USB_ERR_CREATE_SIME_FAILED;
390 goto error1;
391 }
392
393 /* 线程同步 */
394 mscDev->ThreadSemi = hal_sem_create(0);
395
396 if (mscDev->ThreadSemi == NULL)
397 {
398 hal_log_err("ERR: hal_sem_create dev_lock failed");
399 ret = USB_ERR_CREATE_SIME_FAILED;
400 goto error2;
401 }
402
403 mscDev->notify_complete = hal_sem_create(0);
404
405 if (mscDev->notify_complete == NULL)
406 {
407 hal_log_err("ERR: hal_sem_create notify_complete failed");
408 ret = USB_ERR_CREATE_SIME_FAILED;
409 goto error3;
410 }
411
412 mscDev->CtrlReq = (struct usb_ctrlrequest *)usb_buffer_alloc(mscDev->pusb_dev,
413 sizeof(struct usb_ctrlrequest),
414 0,
415 NULL);
416
417 if (mscDev->CtrlReq == NULL)
418 {
419 hal_log_err("ERR: usb_buffer_alloc CtrlReq failed");
420 ret = USB_ERR_MALLOC_FAILED;
421 goto error4;
422 }
423
424 mscDev->iobuf = (__u8 *)usb_buffer_alloc(mscDev->pusb_dev, MSC_IOBUF_SIZE, 0, NULL);
425
426 if (mscDev->iobuf == NULL)
427 {
428 hal_log_err("ERR: usb_buffer_alloc iobuf failed");
429 ret = USB_ERR_MALLOC_FAILED;
430 goto error5;
431 }
432
433 mscDev->UrbWait = hal_sem_create(0);
434
435 if (mscDev->UrbWait == NULL)
436 {
437 hal_log_err("ERR: hal_sem_create UrbWait failed");
438 ret = USB_ERR_CREATE_SIME_FAILED;
439 goto error6;
440 }
441
442 return USB_ERR_SUCCESS;
443 error6:
444 usb_buffer_free(mscDev->pusb_dev, MSC_IOBUF_SIZE, (void *)(mscDev->iobuf), 0);
445 error5:
446 usb_buffer_free(mscDev->pusb_dev, sizeof(*mscDev->CtrlReq), (void *)(mscDev->CtrlReq), 0);
447 error4:
448 hal_sem_delete(mscDev->notify_complete);
449 error3:
450 hal_sem_delete(mscDev->ThreadSemi);
451 error2:
452 hal_sem_delete(mscDev->DevLock);
453 error1:
454 hal_sem_delete(mscDev->scan_lock);
455 error0:
456 usb_free_urb(mscDev->CurrentUrb);
457 return ret;
458 }
459
460 /*
461 *******************************************************************************
462 * mscDevFree
463 *
464 * Description:
465 *
466 *
467 * Parameters:
468 * mscDev -- input. msc设备信息
469 *
470 * Return value:
471 * none
472 *
473 * note:
474 * none
475 *
476 *******************************************************************************
477 */
mscDevFree(__mscDev_t * mscDev)478 static void mscDevFree(__mscDev_t *mscDev)
479 {
480 __u8 err = 0;
481
482 if (mscDev->ThreadSemi)
483 {
484 hal_sem_delete(mscDev->ThreadSemi);
485 }
486
487 if (mscDev->scan_lock)
488 {
489 hal_sem_delete(mscDev->scan_lock);
490 }
491
492 if (mscDev->DevLock)
493 {
494 hal_sem_delete(mscDev->DevLock);
495 }
496
497 if (mscDev->notify_complete)
498 {
499 hal_sem_delete(mscDev->notify_complete);
500 }
501
502 if (mscDev->UrbWait)
503 {
504 hal_sem_delete(mscDev->UrbWait);
505 }
506
507 if (mscDev->CtrlReq)
508 {
509 usb_buffer_free(mscDev->pusb_dev, sizeof(*mscDev->CtrlReq), (void *)(mscDev->CtrlReq), 0);
510 }
511
512 if (mscDev->iobuf)
513 {
514 usb_buffer_free(mscDev->pusb_dev, MSC_IOBUF_SIZE, (void *)(mscDev->iobuf), 0);
515 }
516
517 usb_free_urb(mscDev->CurrentUrb);
518 /* Remove our private data from the interface */
519 usb_mod_usb_set_intf_priv_data(mscDev->pusb_intf, NULL);
520 free_mscDev_id(mscDev->mscDevNo);
521 }
522
523 /*
524 *******************************************************************************
525 * SetMscDevState
526 *
527 * Description:
528 *
529 *
530 * Parameters:
531 *
532 *
533 * Return value:
534 * none
535 *
536 * note:
537 * none
538 *
539 *******************************************************************************
540 */
SetMscDevState(__mscDev_t * mscDev,mscDev_state_t state)541 static void SetMscDevState(__mscDev_t *mscDev, mscDev_state_t state)
542 {
543 unsigned int cup_sr = 0;
544 ENTER_CRITICAL(cup_sr);
545 mscDev->state = state;
546 EXIT_CRITICAL(cup_sr);
547 }
548
549 /*
550 *******************************************************************************
551 * mscDevOnline
552 *
553 * Description:
554 *
555 *
556 * Parameters:
557 *
558 *
559 * Return value:
560 * none/error
561 *
562 * note:
563 * none
564 *
565 *******************************************************************************
566 */
mscDevOnline(__mscDev_t * mscDev)567 unsigned int mscDevOnline(__mscDev_t *mscDev)
568 {
569 return (mscDev->state == MSC_DEV_ONLINE);
570 }
571
572 /*
573 *******************************************************************************
574 * GetDeviceInfo
575 *
576 * Description:
577 *
578 *
579 * Parameters:
580 *
581 *
582 * Return value:
583 * void
584 *
585 * note:
586 * none
587 *
588 *******************************************************************************
589 */
GetDeviceInfo(__mscDev_t * mscDev,unsigned int index)590 static void GetDeviceInfo(__mscDev_t *mscDev, unsigned int index)
591 {
592 struct usb_interface_descriptor *idesc = &(mscDev->pusb_intf->cur_altsetting->desc);
593 mscDev->SubClass = idesc->bInterfaceSubClass ;
594 mscDev->Protocol = idesc->bInterfaceProtocol ;
595 return;
596 }
597
598 /*
599 *******************************************************************************
600 * GetTransport
601 *
602 * Description:
603 * 获取msc设备的传输方式
604 *
605 * Parameters:
606 * mscDev 获取 input.msc设备信息
607 *
608 * Return value:
609 * 0 成功
610 * !0 失败
611 *
612 * note:
613 * none
614 *
615 *******************************************************************************
616 */
GetTransport(__mscDev_t * mscDev)617 static int GetTransport(__mscDev_t *mscDev)
618 {
619 // printf("%s %d %s Protocol:%x\n", __FILE__, __LINE__, __func__, mscDev->Protocol);
620 switch (mscDev->Protocol)
621 {
622 case USBMSC_INTERFACE_PROTOCOL_BOT:
623 mscDev->transport_name = "BulkOnly";
624 mscDev->ResetRecovery = mscResetRecovery;
625 mscDev->Transport = mscBoTransport;
626 mscDev->StopTransport = mscBoStopTransport;
627 break;
628
629 default:
630 hal_log_info("ERR: not support transport Protocol(%x)", mscDev->Protocol);
631 mscDev->transport_name = "unkown";
632 mscDev->ResetRecovery = NULL;
633 mscDev->Transport = NULL;
634 mscDev->StopTransport = NULL;
635 return USB_ERR_UNKOWN_ERROR;
636 }
637
638 return USB_ERR_SUCCESS;
639 }
640
641 /*
642 *******************************************************************************
643 * GetProtocol
644 *
645 * Description:
646 * 获取msc设备的传输方式
647 *
648 * Parameters:
649 * mscDev 获取 input.msc设备信息
650 *
651 * Return value:
652 * 0 成功
653 * !0 失败
654 *
655 * note:
656 * none
657 *
658 *******************************************************************************
659 */
GetProtocol(__mscDev_t * mscDev)660 static int GetProtocol(__mscDev_t *mscDev)
661 {
662 switch (mscDev->SubClass)
663 {
664 case USBMSC_SUBCLASS_RBC:
665 mscDev->Protocol_name = "Reduced Block Commands (RBC)";
666 mscDev->ProtocolHandler = mscScsiCommand;
667 break;
668
669 case USBMSC_SUBCLASS_8020:
670 mscDev->Protocol_name = "8020i";
671 mscDev->ProtocolHandler = mscATAPICommand;
672 break;
673
674 case USBMSC_SUBCLASS_QIC:
675 mscDev->Protocol_name = "QIC-157";
676 mscDev->ProtocolHandler = mscQIC157Command;
677 break;
678
679 case USBMSC_SUBCLASS_UFI:
680 mscDev->Protocol_name = "Uniform Floppy Interface (UFI)";
681 mscDev->ProtocolHandler = mscUFICommand;
682 break;
683
684 case USBMSC_SUBCLASS_8070:
685 mscDev->Protocol_name = "8070i";
686 mscDev->ProtocolHandler = mscQIC157Command;
687 break;
688
689 case USBMSC_SUBCLASS_SCSI:
690 mscDev->Protocol_name = "Reduced Block Commands (RBC)";
691 mscDev->ProtocolHandler = mscScsiCommand;
692 break;
693
694 default:
695 hal_log_info("ERR: not support transport SubClass(%x)", mscDev->SubClass);
696 return USB_ERR_UNKOWN_ERROR;
697 }
698
699 return USB_ERR_SUCCESS;
700 }
701
702 /*
703 *******************************************************************************
704 * CreatePipes
705 *
706 * Description:
707 * 创建管道函数
708 *
709 * Parameters:
710 * mscDev 获取 input.msc设备信息
711 *
712 * Return value:
713 * 0 成功
714 * !0 失败
715 *
716 * note:
717 * none
718 *
719 *******************************************************************************
720 */
721
CreatePipes(__mscDev_t * mscDev)722 static int CreatePipes(__mscDev_t *mscDev)
723 {
724 struct usb_host_virt_interface *altsetting = mscDev->pusb_intf->cur_altsetting;
725 struct usb_endpoint_descriptor *ep = NULL;
726 struct usb_endpoint_descriptor *ep_in = NULL;
727 struct usb_endpoint_descriptor *ep_out = NULL;
728 struct usb_endpoint_descriptor *ep_int = NULL;
729 int i = 0;
730
731 /*
732 * Find the endpoints we need.
733 * We are expecting a minimum of 2 endpoints - in and out (bulk).
734 * An optional interrupt is OK (necessary for CBI protocol).
735 * We will ignore any others.
736 */
737 for (i = 0; i < altsetting->desc.bNumEndpoints; i++)
738 {
739 ep = &altsetting->endpoint[i].desc;
740
741 /* Is it a BULK endpoint? */
742 if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
743 == USB_ENDPOINT_XFER_BULK)
744 {
745 /* BULK in or out? */
746 if (ep->bEndpointAddress & USB_DIR_IN)
747 {
748 ep_in = ep;
749 }
750 else
751 {
752 ep_out = ep;
753 }
754 }
755 /* Is it an interrupt endpoint? */
756 else if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
757 == USB_ENDPOINT_XFER_INT)
758 {
759 ep_int = ep;
760 }
761 }
762
763 if (!ep_in || !ep_out || (mscDev->Protocol == USBMSC_INTERFACE_PROTOCOL_CBIT && !ep_int))
764 {
765 hal_log_err("Endpoint sanity check failed! Rejecting dev.");
766 return USB_ERR_UNKOWN_ERROR;
767 }
768
769 /* Calculate and store the pipe values */
770 mscDev->CtrlOut = usb_sndctrlpipe(mscDev->pusb_dev, 0);
771 mscDev->CtrlIn = usb_rcvctrlpipe(mscDev->pusb_dev, 0);
772 mscDev->BulkOut = usb_sndbulkpipe(mscDev->pusb_dev,
773 ep_out->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
774 mscDev->BulkIn = usb_rcvbulkpipe(mscDev->pusb_dev,
775 ep_in->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
776
777 if (ep_int)
778 {
779 mscDev->IntIn = usb_rcvintpipe(mscDev->pusb_dev,
780 ep_int->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
781 mscDev->EpInterval = ep_int->bInterval;
782 }
783
784 return USB_ERR_SUCCESS;
785 }
786
787 /*
788 *******************************************************************************
789 * mscDevAdd
790 *
791 * Description:
792 * 添加msc设备
793 *
794 * Parameters:
795 * mscDev : input. msc设备信息
796 *
797 * Return value:
798 * None
799 *
800 * note:
801 * 无
802 *
803 *******************************************************************************
804 */
mscDevAdd(__mscDev_t * mscDev)805 static void mscDevAdd(__mscDev_t *mscDev)
806 {
807 unsigned int i = 0;
808 int ret = 0;
809
810 if (mscDev == NULL)
811 {
812 printf("ERR: mscDevAdd input error");
813 return;
814 }
815
816 // printf("mscDev->MaxLun=%d", mscDev->MaxLun);
817
818 /* probe lun */
819 for (i = 0; i < mscDev->MaxLun; i++)
820 {
821 __mscLun_t *mscLun = NULL;
822 mscLun = mscLun_alloc();
823
824 if (mscLun == NULL)
825 {
826 hal_log_err("ERR: MscLun_alloc failed");
827 return;
828 }
829
830 mscLun->mscDev = mscDev;
831 mscLun->LunNo = i;
832 mscLun->DiskSubClass = mscDev->SubClass;
833 mscLun->RemoveAble = 1; /* 默认为可移动设备 */
834 mscDev->Lun[i] = mscLun;
835 hal_log_info("begin mscLunAdd\n");
836 ret = mscLunAdd(mscLun);
837 hal_log_info("end mscLunAdd\n");
838
839 if (ret != USB_ERR_SUCCESS)
840 {
841 hal_log_err("ERR: probe Lun(%d) failed", i);
842 continue;
843 }
844
845 /* 判断设备是否可移动设备, 若不是则delay */
846 if (mscLun->RemoveAble == 0)
847 {
848 mscDev->SuspendTime = 10000; /* 10s */
849 }
850 else
851 {
852 mscDev->SuspendTime = 0;
853 }
854
855 usbh_disk_save_time(mscDev->SuspendTime);
856 }
857
858 return;
859 }
860
861 /*
862 *******************************************************************************
863 * mscDevDel
864 *
865 * Description:
866 *
867 *
868 * Parameters:
869 * mscDev : input. msc设备信息
870 *
871 * Return value:
872 * 无
873 *
874 * note:
875 * 无
876 *
877 *******************************************************************************
878 */
mscDevDel(__mscDev_t * mscDev)879 static void mscDevDel(__mscDev_t *mscDev)
880 {
881 unsigned int i = 0;
882
883 if (mscDev == NULL)
884 {
885 hal_log_err("ERR: mscDevDel input error");
886 return;
887 }
888
889 /* remove lun */
890 for (i = 0; i < mscDev->MaxLun; i++)
891 {
892 __mscLun_t *mscLun = NULL;
893 mscLun = mscDev->Lun[i];
894
895 if (mscLun == NULL)
896 {
897 hal_log_err("ERR: mscLun == NULL");
898 return;
899 }
900
901 mscLunDel(mscLun);
902 mscLun_free(mscLun);
903 usbh_disk_del_time(mscDev->SuspendTime);
904 }
905
906 return;
907 }
908
909 /*
910 *******************************************************************************
911 * MediaChangeThread
912 *
913 * Description:
914 * 媒体变化线程
915 *
916 * Parameters:
917 * p_arg : input. 为mscDev, msc设备信息
918 *
919 * Return value:
920 * 无
921 *
922 * note:
923 * 无
924 *
925 *******************************************************************************
926 */
927
MediaChangeThread(void * p_arg)928 static void MediaChangeThread(void *p_arg)
929 {
930 __mscDev_t *mscDev = (__mscDev_t *)p_arg;
931 hal_sem_post(mscDev->notify_complete);
932 while (1)
933 {
934 unsigned int i = 0;
935 //--<1>--销毁线程
936 //TryTo//KillThreadSelf("MediaChangeThread");
937
938 for (i = 0; i < mscDev->MaxLun; i++)
939 {
940 __mscLun_t *mscLun = NULL;
941 mscLun = mscDev->Lun[i];
942
943 if (mscLun == NULL)
944 {
945 hal_log_err("ERR: MediaChangeThread: mscLun is NULL");
946 continue;
947 }
948
949 if (mscLun->MediaChange)
950 {
951 mscLun->MediaChange(mscLun);
952 }
953 }
954
955 /* delay 1.25s */
956 hal_msleep(1250);
957 }
958 }
959
960 /*
961 *******************************************************************************
962 * mscDevScanThread
963 *
964 * Description:
965 * mscDev扫描
966 *
967 * Parameters:
968 * p_arg : input. 指向mscDev, msc设备信息
969 *
970 * Return value:
971 * 无
972 *
973 * note:
974 * 无
975 *
976 *******************************************************************************
977 */
mscDevScanThread(void * p_arg)978 static void mscDevScanThread(void *p_arg)
979 {
980 __mscDev_t *mscDev = (__mscDev_t *)p_arg;
981 mscDevAdd(mscDev);
982 hal_sem_post(mscDev->notify_complete);
983 //KillThreadSelf();
984 }
985
986
987 /*
988 *******************************************************************************
989 * QueueCmnd
990 *
991 * Description:
992 * 将命令队列提交到Lun
993 *
994 * Parameters:
995 * mscLun ： input. 对应的Lun
996 * scsi_cmnd : input. 命令
997 *
998 * Return value:
999 * 0 成功
1000 * !0 失败
1001 *
1002 * note:
1003 * 无
1004 *
1005 *******************************************************************************
1006 */
mscDevQueueCmnd(__mscLun_t * mscLun,__ScsiCmnd_t * ScsiCmnd)1007 int mscDevQueueCmnd(__mscLun_t *mscLun, __ScsiCmnd_t *ScsiCmnd)
1008 {
1009 __mscDev_t *mscDev = NULL;
1010 unsigned int sr = 0 ;
1011 int val = 0;
1012
1013 if (ScsiCmnd == NULL)
1014 {
1015 hal_log_err("ERR: invalid argment");
1016 return USB_ERR_BAD_ARGUMENTS;
1017 }
1018
1019 if (mscLun == NULL)
1020 {
1021 hal_log_err("ERR: MscTransport: input error, mscLun = 0x%x, ScsiCmnd = %x", mscLun, ScsiCmnd);
1022 ScsiCmnd->Result = USB_STOR_TRANSPORT_ERROR;
1023 return USB_ERR_BAD_ARGUMENTS;
1024 }
1025
1026 //DMSG_MSC_TEST("mscDevQueueCmnd: cmnd = %x", ((__u8 *)(ScsiCmnd->cmnd.CommandBlock))[0]);
1027 mscDev = mscLun->mscDev;
1028
1029 if (mscDev == NULL)
1030 {
1031 hal_log_err("ERR: MscTransport: input error, mscDev == NULL");
1032 ScsiCmnd->Result = USB_STOR_TRANSPORT_ERROR;
1033 return USB_ERR_BAD_ARGUMENTS;
1034 }
1035
1036 /* if mscDev is Busy, then all cmd to cmd_list */
1037 if (!mscDevOnline(mscDev))
1038 {
1039 hal_log_err("ERR: mscDevice is %s",
1040 (mscDev->state == MSC_DEV_OFFLINE) ? "offline" : "died");
1041 ScsiCmnd->Result = USB_STOR_TRANSPORT_ERROR;
1042 return USB_ERR_IO_DEVICE_OFFLINE;
1043 }
1044
1045 /* add command to cmd_list */
1046 ENTER_CRITICAL(sr);
1047 list_head_malloc_and_add((void *)ScsiCmnd, &(mscDev->cmd_list));
1048 EXIT_CRITICAL(sr);
1049 /* wakeup mscDev main thread */
1050 //UsbThreadWakeUp(mscDev->ThreadSemi);
1051 if (!hal_sem_getvalue(mscDev->ThreadSemi, &val))
1052 {
1053 hal_sem_post(mscDev->ThreadSemi);
1054 }
1055 return USB_ERR_SUCCESS;
1056 }
1057
1058 /*
1059 *******************************************************************************
1060 * mscCmndDone
1061 *
1062 * Description:
1063 * 处理命令完成后的回调函数
1064 *
1065 * Parameters:
1066 * mscLun ： input. 对应的Lun
1067 * scsi_cmnd : input. 命令
1068 * TransStatus : input. 数据传输状态
1069 *
1070 * Return value:
1071 * 无
1072 *
1073 * note:
1074 * 无
1075 *
1076 *******************************************************************************
1077 */
mscCmndDone(__mscDev_t * mscDev,__ScsiCmnd_t * ScsiCmnd,int TransStatus)1078 static void mscCmndDone(__mscDev_t *mscDev, __ScsiCmnd_t *ScsiCmnd, int TransStatus)
1079 {
1080 unsigned int sr = 0 ;
1081
1082 if (ScsiCmnd == NULL)
1083 {
1084 return;
1085 }
1086
1087 if (mscDev->state != MSC_DEV_OFFLINE)
1088 {
1089 /* need retry? */
1090 if (TransStatus == USB_STOR_TRANSPORT_ERROR && (ScsiCmnd->retries < ScsiCmnd->allowed))
1091 {
1092 if (mscGetDataTransportReason(ScsiCmnd->sc_lun, ScsiCmnd) == USB_ERR_COMMAND_NEED_RETRY)
1093 {
1094 ScsiCmnd->retries++;
1095 hal_log_err("ERR: do command(%x) failed, need retry, retries = %d, ScsiCmnd->allowed = %d",
1096 ((__u8 *)(ScsiCmnd->cmnd.CommandBlock))[0], ScsiCmnd->retries, ScsiCmnd->allowed);
1097 return ;
1098 }
1099 else
1100 {
1101 hal_log_err("ERR: mscCmndDone: media is not present");
1102 }
1103 }
1104
1105 //DMSG_MSC_TEST("mscCmndDone: cmnd = %x", ((__u8 *)(ScsiCmnd->cmnd.CommandBlock))[0]);
1106
1107 /* retries = allowed = 0 ? */
1108 if (ScsiCmnd->retries > ScsiCmnd->allowed)
1109 {
1110 hal_log_err("ERR: ScsiCmnd(%x) retry %d times, maybe device is died",
1111 ((__u8 *)(ScsiCmnd->cmnd.CommandBlock))[0], ScsiCmnd->retries);
1112 /* 不要使用异步执行操作，因为设备可能不支持并且可能会导致失败 */
1113 }
1114 }
1115 else
1116 {
1117 hal_log_err("ERR: mscCmndDone: device is offline");
1118 }
1119
1120 /* Done command */
1121 ENTER_CRITICAL(sr);
1122 list_head_unlink_and_del(mscDev->cmd_list.next);
1123 ScsiCmnd->Result = TransStatus;
1124 EXIT_CRITICAL(sr);
1125
1126 if (ScsiCmnd->Done)
1127 {
1128 ScsiCmnd->Done(ScsiCmnd);
1129 }
1130
1131 return ;
1132 }
1133
1134 /*
1135 *******************************************************************************
1136 * mscMainThread
1137 *
1138 * Description:
1139 * 线程函数，控制整个系统运行。
1140 *
1141 * Parameters:
1142 * p_arg -- input. 对象指针，mscDev, msc设备信息。
1143 *
1144 * Return value:
1145 * 无
1146 *
1147 * note:
1148 * 无
1149 *
1150 *******************************************************************************
1151 */
mscMainThread(void * p_arg)1152 static void mscMainThread(void *p_arg)
1153 {
1154 __mscDev_t *mscDev = (__mscDev_t *)p_arg;
1155 __ScsiCmnd_t *ScsiCmnd = NULL;
1156 int TransStatus = 0;
1157 unsigned int sr = 0 ;
1158 hal_sem_post(mscDev->notify_complete);
1159
1160 while (1)
1161 {
1162 //--<1>--线程退出
1163 //TryTo//KillThreadSelf("mscMainThread");
1164 /* sleep */
1165 //UsbThreadSleep(mscDev->ThreadSemi);
1166 // kthread_stop(mscDev->MainThreadId);
1167 hal_sem_wait(mscDev->ThreadSemi);
1168 /* cmd_list is empty?
1169 * 如果mscDevQueueCmnd的cmd加入了cmd_list队列就会唤醒mscMainThread线程去执行，
1170 * for循环从cmd_list取出一个cmd执行完再继续取下一个。
1171 * 所以UsbThreadWakeUp函数用于将mscMainThread线程唤醒，去执行已经加入到cmd_list的cmd。
1172 */
1173 if (usb_list_empty(&(mscDev->cmd_list)))
1174 {
1175 hal_log_err("Wrn: mscDev cmd_list is empty");
1176 continue;
1177 }
1178
1179 for (; !usb_list_empty(&(mscDev->cmd_list));)
1180 {
1181 /* Get command */
1182 ScsiCmnd = (__ScsiCmnd_t *)mscDev->cmd_list.next->data;
1183
1184 if (ScsiCmnd == NULL)
1185 {
1186 hal_log_err("Wrn: mscDev cmd_list is not empty, but ScsiCmnd is NULL");
1187 ENTER_CRITICAL(sr);
1188 list_head_unlink_and_del(mscDev->cmd_list.next);
1189 EXIT_CRITICAL(sr);
1190 continue;
1191 }
1192
1193 /* transport */
1194 if (mscDev->ProtocolHandler)
1195 {
1196 TransStatus = mscDev->ProtocolHandler(mscDev, ScsiCmnd);
1197 }
1198 else
1199 {
1200 hal_log_err("ERR: mscDev ProtocolHandler is NULL");
1201 ScsiCmnd->Result = USB_STOR_TRANSPORT_ERROR;
1202 TransStatus = USB_STOR_TRANSPORT_GOOD;
1203 }
1204
1205 /* done cmnd */
1206 mscCmndDone(mscDev, ScsiCmnd, TransStatus);
1207 }
1208 }
1209 }
1210
1211 /*
1212 *******************************************************************************
1213 * mscDevProbe
1214 *
1215 * Description:
1216 * 设备探测函数
1217 *
1218 * Parameters:
1219 * intf ： input. USB接口信息
1220 * table_item : input. 匹配项
1221 *
1222 * Return value:
1223 * 0 成功
1224 * !0 失败
1225 *
1226 * note:
1227 * 备注
1228 *
1229 *******************************************************************************
1230 */
mscDevProbe(struct usb_interface * intf,const struct usb_drv_dev_match_table * table_item)1231 static int32_t mscDevProbe(struct usb_interface *intf, const struct usb_drv_dev_match_table *table_item)
1232 {
1233 const s32 match_table_index = table_item - msc_match_table;
1234 __mscDev_t *mscDev = NULL;
1235 int ret = 0;
1236 unsigned char err = 0;
1237 struct rt_thread *mscDev_Scan_Id = 0;
1238
1239 hal_log_info("mscDevProbe begin");
1240 if (intf == NULL || table_item == NULL)
1241 {
1242 hal_log_err("ERR: mscDevProbe: input error");
1243 return -1;
1244 }
1245
1246 //----------------------------------------------------------------
1247 // 初始化mscDev
1248 //----------------------------------------------------------------
1249 /* 初始化一个mscDev */
1250 mscDev = (__mscDev_t *)hal_malloc(sizeof(__mscDev_t));
1251
1252 if (mscDev == NULL)
1253 {
1254 hal_log_err("ERR: hal_malloc failed");
1255 ret = -1;
1256 goto error0;
1257 }
1258
1259 memset(mscDev, 0, sizeof(__mscDev_t));
1260 ret = mscDevInit(mscDev, intf);
1261
1262 if (ret != USB_ERR_SUCCESS)
1263 {
1264 hal_log_err("ERR: mscDevInit failed");
1265 ret = -1;
1266 goto error1;
1267 }
1268
1269 GetDeviceInfo(mscDev, match_table_index);
1270 /* 获取 SubClass */
1271 ret = GetProtocol(mscDev);
1272
1273 if (ret != USB_ERR_SUCCESS)
1274 {
1275 hal_log_err("ERR: GetProtocol failed");
1276 ret = -1;
1277 goto error2;
1278 }
1279
1280 /* 获取 Transport */
1281 ret = GetTransport(mscDev);
1282
1283 if (ret != USB_ERR_SUCCESS)
1284 {
1285 hal_log_err("ERR: GetTransport failed");
1286 ret = -1;
1287 goto error3;
1288 }
1289
1290 /* 创建管道 */
1291 ret = CreatePipes(mscDev);
1292 if (ret != USB_ERR_SUCCESS)
1293 {
1294 hal_log_err("ERR: CreatePipes failed");
1295 ret = -1;
1296 goto error4;
1297 }
1298
1299
1300 //----------------------------------------------------------------
1301 //识别mscDev
1302 //----------------------------------------------------------------
1303 SetMscDevState(mscDev, MSC_DEV_ONLINE);
1304 /* 获取MaxLun */
1305 mscDev->MaxLun = mscGetMaxLun(mscDev) + 1;
1306
1307 if (mscDev->MaxLun > MSC_MAX_LUN)
1308 {
1309 hal_log_err("ERR: MaxLun = %d, mscDrv only support %d Lun", mscDev->MaxLun, MSC_MAX_LUN);
1310 mscDev->MaxLun = MSC_MAX_LUN;
1311 }
1312
1313 /* msc main thread */
1314 mscDev->MainThreadId = kthread_run((void *)mscMainThread,
1315 (void *)mscDev,
1316 "MscMainThread");
1317
1318 if (IS_ERR((unsigned long)mscDev->MainThreadId))
1319 {
1320 hal_log_err("ERR: create MainThreadId failed");
1321 ret = -1;
1322 goto error5;
1323 }
1324
1325 hal_sem_wait(mscDev->notify_complete);
1326 /* mscDev scan thread */
1327 mscDev_Scan_Id = kthread_run((void *)mscDevScanThread,
1328 (void *)mscDev,
1329 "mscDevScanThread");
1330
1331 if (IS_ERR((unsigned long)mscDev_Scan_Id))
1332 {
1333 hal_log_err("ERR: create mscDevScanThread failed");
1334 ret = -1;
1335 goto error6;
1336 }
1337
1338 hal_sem_wait(mscDev->notify_complete);
1339 hal_log_info("mscDevScanThread end...");
1340 /* media change thread */
1341 mscDev->MediaChangeId = kthread_run((void *)MediaChangeThread,
1342 (void *)mscDev,
1343 "MediaChangeThread");
1344
1345 if (IS_ERR((unsigned long)mscDev->MediaChangeId))
1346 {
1347 hal_log_err("ERR: create MediaChangeId failed");
1348 ret = -1;
1349 goto error7;
1350 }
1351
1352 hal_sem_wait(mscDev->notify_complete);
1353 return 0;
1354 error7:
1355 kthread_stop(mscDev_Scan_Id);
1356 error6:
1357 kthread_stop(mscDev->MainThreadId);
1358 error5:
1359 error4:
1360 error3:
1361 error2:
1362 mscDevFree(mscDev);
1363 error1:
1364 hal_free(mscDev);
1365 error0:
1366 hal_log_err("ERR: USB Mass Storage Driver probe failed");
1367 return ret;
1368 }
1369
1370
1371 /*
1372 *******************************************************************************
1373 * mscDevSuspend
1374 *
1375 * Description:
1376 * 挂起设备
1377 *
1378 * Parameters:
1379 * intf ： input. USB接口信息
1380 *
1381 * Return value:
1382 * 0 成功
1383 * !0 失败
1384 *
1385 * note:
1386 * 无
1387 *
1388 *******************************************************************************
1389 */
mscDevSuspend(struct usb_interface * intf)1390 static int32_t mscDevSuspend(struct usb_interface *intf)
1391 {
1392 __mscDev_t *mscDev = NULL;
1393
1394 if (intf == NULL)
1395 {
1396 hal_log_err("ERR: mscDevRemove: input error");
1397 return -1;
1398 }
1399
1400 mscDev = (__mscDev_t *)usb_mod_usb_get_intf_priv_data(intf);
1401
1402 if (mscDev == NULL)
1403 {
1404 hal_log_err("ERR: mscDev = NULL");
1405 return -1;
1406 }
1407
1408 /* suspend interface */
1409 /* delay for suspend successful */
1410 hal_log_info("mscDevSuspend: SuspendTime = %dms", mscDev->SuspendTime);
1411 // hal_msleep(mscDev->SuspendTime);
1412 return 0;
1413 }
1414
1415
1416 /*
1417 *******************************************************************************
1418 * mscDevRemove
1419 *
1420 * Description:
1421 * msc设备移除
1422 *
1423 * Parameters:
1424 * intf ： input. USB接口信息
1425 *
1426 * Return value:
1427 * 0 成功
1428 * !0 失败
1429 *
1430 * note:
1431 * 无
1432 *
1433 *******************************************************************************
1434 */
mscDevRemove(struct usb_interface * intf)1435 static void mscDevRemove(struct usb_interface *intf)
1436 {
1437 __mscDev_t *mscDev = NULL;
1438
1439 if (intf == NULL)
1440 {
1441 hal_log_err("ERR: mscDevRemove: input error");
1442 return ;
1443 }
1444
1445 mscDev = (__mscDev_t *)usb_mod_usb_get_intf_priv_data(intf);
1446
1447 if (mscDev == NULL)
1448 {
1449 hal_log_err("ERR: mscDev = NULL");
1450 return ;
1451 }
1452
1453 SetMscDevState(mscDev, MSC_DEV_OFFLINE);
1454 hal_log_info("mscDevRemove: SetMscDevState MSC_DEV_OFFLINE");
1455 /* 停止当前传输 */
1456 mscDev->StopTransport(mscDev);
1457 /* 断开mscDev与所有Lun的关联 */
1458 mscDevDel(mscDev);
1459 /* kill media change thrad */
1460 kthread_stop(mscDev->MediaChangeId);
1461 /* kill main thrad */
1462 //kthread_stop(mscDev->MainThreadId, mscDev->ThreadSemi);
1463 kthread_stop(mscDev->MainThreadId);
1464 if (mscDev->ThreadSemi)
1465 {
1466 hal_sem_delete(mscDev->ThreadSemi);
1467 mscDev->ThreadSemi = NULL;
1468 }
1469 /* 释放mscDev资源 */
1470 mscDevFree(mscDev);
1471 hal_free(mscDev);
1472 hal_log_info("mscDevRemove complete");
1473 return ;
1474 }
1475
1476 /*
1477 *******************************************************************************
1478 * mscDrv_init
1479 *
1480 * Description:
1481 * msc驱动初始化
1482 *
1483 * Parameters:
1484 * drv 为input.msc驱动
1485 *
1486 * Return value:
1487 * 0 成功
1488 * !0 失败
1489 *
1490 * note:
1491 *
1492 *
1493 *******************************************************************************
1494 */
mscDrvInit(struct usb_host_func_drv * drv)1495 static int mscDrvInit(struct usb_host_func_drv *drv)
1496 {
1497 if (drv == NULL)
1498 {
1499 hal_log_err("ERR: mscDrv_init: input error");
1500 return -1;
1501 }
1502
1503 USB_INIT_LIST_HEAD(&(drv->virt_dev_list));
1504 drv->func_drv_name = MSC_DRV_NAME;
1505 drv->func_drv_auther = MSC_DRV_AUTHOR;
1506 drv->probe = mscDevProbe;
1507 drv->disconnect = mscDevRemove;
1508 drv->suspend = mscDevSuspend;
1509 drv->resume = NULL;
1510 drv->match_table = msc_match_table;
1511 return 0;
1512 }
1513
1514 /*
1515 *******************************************************************************
1516 * scsi_bus_drv_reg
1517 *
1518 * Description:
1519 * SCSI总线驱动注册函数
1520 *
1521 * Parameters:
1522 * drv : input. 驱动
1523 *
1524 * Return value:
1525 * EPDK_OK / EPDK_FAIL
1526 *
1527 * note:
1528 * 无
1529 *
1530 *******************************************************************************
1531 */
mscInit(void)1532 int mscInit(void)
1533 {
1534 int ret = 0;
1535
1536 memset(&mscDrv, 0, sizeof(struct usb_host_func_drv));
1537 mscDev_id_array = 0;
1538 init_usbh_buff_manager();
1539 usbh_disk_time_init();
1540 /* 数据库客户端需要映射disk状态, 这就是针对disk状态 */
1541 usbh_disk_info_reg();
1542
1543 if (mscDrvInit(&mscDrv) != 0)
1544 {
1545 hal_log_err("ERR: mscDrv_init failed");
1546 return -1;
1547 }
1548
1549 ret = usb_host_func_drv_reg(&mscDrv);
1550 if (ret != 0)
1551 {
1552 hal_log_err("ERR: mscInit: Reg driver %s failed", mscDrv.func_drv_name);
1553 return -1;
1554 }
1555 return 0;
1556 }
1557
1558 /*
1559 *******************************************************************************
1560 * scsi_bus_drv_reg
1561 *
1562 * Description:
1563 * SCSI总线驱动注册
1564 *
1565 * Parameters:
1566 * drv : input. 驱动
1567 *
1568 * Return value:
1569 * EPDK_OK / EPDK_FAIL
1570 *
1571 * note:
1572 * 无
1573 *
1574 *******************************************************************************
1575 */
mscExit(void)1576 int mscExit(void)
1577 {
1578 int ret = 0;
1579 ret = usb_host_func_drv_unreg(&mscDrv);
1580
1581 if (ret != 0)
1582 {
1583 hal_log_err("ERR: mscExit: UnReg driver %s failed", mscDrv.func_drv_name);
1584 return -1;
1585 }
1586
1587 usbh_disk_info_unreg();
1588 exit_usbh_buff_manager();
1589 usbh_disk_time_exit();
1590 return 0;
1591 }
1592
1593
1594
1595
1596