?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove building with NOCRYPTO option
[minix3.git] / minix / drivers / usb / usb_storage / usb_storage.c
blobc40789a374ea6668a7ddb72459ffc0ea0bbe4eee
1 /*
2 * Minix3 USB mass storage driver implementation
3 * using DDEkit, and libblockdriver
4 */
5
6 #include <sys/cdefs.h> /* __CTASSERT() */
7 #include <sys/ioc_disk.h> /* cases for mass_storage_ioctl */
8 #ifdef USB_STORAGE_SIGNAL
9 #include <sys/signal.h> /* signal handling */
10 #endif
11
12 #include <ddekit/minix/msg_queue.h>
13 #include <ddekit/thread.h>
14 #include <ddekit/usb.h>
15
16 #include <minix/blockdriver.h>
17 #include <minix/com.h> /* for msg_queue ranges */
18 #include <minix/drvlib.h> /* DEV_PER_DRIVE, partition */
19 #include <minix/ipc.h> /* message */
20 #include <minix/safecopies.h> /* GRANT_VALID */
21 #include <minix/sef.h>
22 #include <minix/sysutil.h> /* panic */
23 #include <minix/usb.h> /* structures like usb_ctrlrequest */
24 #include <minix/usb_ch9.h> /* descriptor structures */
25
26 #include <assert.h>
27 #include <limits.h> /* ULONG_MAX */
28 #include <time.h> /* nanosleep */
29
30 #include "common.h"
31 #include "bulk.h"
32 #include "usb_storage.h"
33 #include "urb_helper.h"
34 #include "scsi.h"
35
36
37 /*---------------------------*
38 * declared functions *
39 *---------------------------*/
40 /* TODO: these are missing from DDE header files */
41 extern void ddekit_minix_wait_exit(void);
42 extern void ddekit_shutdown(void);
43
44 /* SCSI URB related prototypes */
45 static int mass_storage_send_scsi_cbw_out(int, scsi_transfer *);
46 static int mass_storage_send_scsi_data_in(void *, unsigned int);
47 static int mass_storage_send_scsi_data_out(void *, unsigned int);
48 static int mass_storage_send_scsi_csw_in(void);
49
50 #ifdef MASS_RESET_RECOVERY
51 /* Bulk only URB related prototypes */
52 static int mass_storage_reset_recovery(void);
53 static int mass_storage_send_bulk_reset(void);
54 static int mass_storage_send_clear_feature(int, int);
55 #endif
56
57 /* SEF related functions */
58 static int mass_storage_sef_hdlr(int, sef_init_info_t *);
59 static void mass_storage_signal_handler(int);
60
61 /* DDEKit IPC related */
62 static void ddekit_usb_task(void *);
63
64 /* Mass storage related prototypes */
65 static void mass_storage_task(void *);
66 static int mass_storage_test(void);
67 static int mass_storage_check_error(void);
68 static int mass_storage_try_first_open(void);
69 static int mass_storage_transfer_restrictions(u64_t, unsigned long);
70 static ssize_t mass_storage_write(unsigned long, endpoint_t, iovec_t *,
71 unsigned int, unsigned long);
72 static ssize_t mass_storage_read(unsigned long, endpoint_t, iovec_t *,
73 unsigned int, unsigned long);
74
75 /* Minix's libblockdriver callbacks */
76 static int mass_storage_open(devminor_t, int);
77 static int mass_storage_close(devminor_t);
78 static ssize_t mass_storage_transfer(devminor_t, int, u64_t, endpoint_t,
79 iovec_t *, unsigned int, int);
80 static int mass_storage_ioctl(devminor_t, unsigned long, endpoint_t,
81 cp_grant_id_t, endpoint_t);
82 static void mass_storage_cleanup(void);
83 static struct device * mass_storage_part(devminor_t);
84 static void mass_storage_geometry(devminor_t, struct part_geom *);
85
86 /* DDEKit's USB driver callbacks */
87 static void usb_driver_completion(void *);
88 static void usb_driver_connect(struct ddekit_usb_dev *, unsigned int);
89 static void usb_driver_disconnect(struct ddekit_usb_dev *);
90
91 /* Simplified enumeration method for endpoint resolution */
92 static int mass_storage_get_endpoints(urb_ep_config *, urb_ep_config *);
93 static int mass_storage_parse_endpoint(usb_descriptor_t *, urb_ep_config *,
94 urb_ep_config *);
95 static int mass_storage_parse_descriptors(char *, unsigned int, urb_ep_config *,
96 urb_ep_config *);
97
98
99 /*---------------------------*
100 * defined variables *
101 *---------------------------*/
102 #define MASS_PACKED __attribute__((__packed__))
103
104 /* Mass Storage callback structure */
105 static struct blockdriver mass_storage = {
106 .bdr_type = BLOCKDRIVER_TYPE_DISK,
107 .bdr_open = mass_storage_open,
108 .bdr_close = mass_storage_close,
109 .bdr_transfer = mass_storage_transfer,
110 .bdr_ioctl = mass_storage_ioctl,
111 .bdr_cleanup = mass_storage_cleanup,
112 .bdr_part = mass_storage_part,
113 .bdr_geometry = mass_storage_geometry,
114 .bdr_intr = NULL,
115 .bdr_alarm = NULL,
116 .bdr_other = NULL,
117 .bdr_device = NULL
118 };
119
120 /* USB callback structure */
121 static struct ddekit_usb_driver mass_storage_driver = {
122 .completion = usb_driver_completion,
123 .connect = usb_driver_connect,
124 .disconnect = usb_driver_disconnect
125 };
126
127 /* Instance of global driver information */
128 mass_storage_state driver_state;
129
130 /* Tags used to pair CBW and CSW for bulk communication
131 * With this we can check if SCSI reply was meant for SCSI request */
132 static unsigned int current_cbw_tag = 0; /* What shall be send next */
133 static unsigned int last_cbw_tag = 0; /* What was sent recently */
134
135 /* Semaphore used to block mass storage thread to
136 * allow DDE dispatcher operation */
137 static ddekit_sem_t * mass_storage_sem = NULL;
138
139 /* Mass storage (using libblockdriver) thread */
140 ddekit_thread_t * mass_storage_thread = NULL;
141
142 /* DDEKit USB message handling thread */
143 ddekit_thread_t * ddekit_usb_thread = NULL;
144
145 /* Static URB buffer size (must be multiple of SECTOR_SIZE) */
146 #define BUFFER_SIZE (64*SECTOR_SIZE)
147
148 /* Large buffer for URB read/write operations */
149 static unsigned char buffer[BUFFER_SIZE];
150
151 /* Length of local buffer where descriptors are temporarily stored */
152 #define MAX_DESCRIPTORS_LEN 128
153
154 /* Maximum 'Test Unit Ready' command retries */
155 #define MAX_TEST_RETRIES 3
156
157 /* 'Test Unit Ready' failure delay time (in nanoseconds) */
158 #define NEXT_TEST_DELAY 50000000 /* 50ms */
159
160
161 /*---------------------------*
162 * defined functions *
163 *---------------------------*/
164 /*===========================================================================*
165 * main *
166 *===========================================================================*/
167 int
168 main(int argc, char * argv[])
169 {
170 MASS_DEBUG_MSG("Starting...");
171
172 /* Store arguments for future parsing */
173 env_setargs(argc, argv);
174
175 /* Clear current state */
176 memset(&driver_state, 0, sizeof(driver_state));
177
178 /* Initialize SEF related callbacks */
179 sef_setcb_init_fresh(mass_storage_sef_hdlr);
180 sef_setcb_init_lu(mass_storage_sef_hdlr);
181 sef_setcb_init_restart(mass_storage_sef_hdlr);
182 sef_setcb_signal_handler(mass_storage_signal_handler);
183
184 /* Initialize DDEkit (involves sef_startup()) */
185 ddekit_init();
186 MASS_DEBUG_MSG("DDEkit ready...");
187
188 /* Semaphore initialization */
189 mass_storage_sem = ddekit_sem_init(0);
190 if (NULL == mass_storage_sem)
191 panic("Initializing mass_storage_sem failed!");
192
193 /* Starting mass storage thread */
194 mass_storage_thread = ddekit_thread_create(mass_storage_task, NULL,
195 "mass_storage_task");
196 if (NULL == mass_storage_thread)
197 panic("Initializing mass_storage_thread failed!");
198
199 MASS_DEBUG_MSG("Storage task (libblockdriver) ready...");
200
201 /* Run USB IPC task to collect messages */
202 ddekit_usb_thread = ddekit_thread_create(ddekit_usb_task, NULL,
203 "ddekit_task" );
204 if (NULL == ddekit_usb_thread)
205 panic("Initializing ddekit_usb_thread failed!");
206
207 MASS_DEBUG_MSG("USB IPC task ready...");
208
209 /* Block and wait until exit signal is received */
210 ddekit_minix_wait_exit();
211 MASS_DEBUG_MSG("Exiting...");
212
213 /* Release objects that were explicitly allocated above */
214 ddekit_thread_terminate(ddekit_usb_thread);
215 ddekit_thread_terminate(mass_storage_thread);
216 ddekit_sem_deinit(mass_storage_sem);
217
218 /* TODO: no ddekit_deinit for proper cleanup? */
219
220 MASS_DEBUG_MSG("Cleanup completed...");
221
222 return EXIT_SUCCESS;
223 }
224
225
226 /*===========================================================================*
227 * mass_storage_send_scsi_cbw_out *
228 *===========================================================================*/
229 static int
230 mass_storage_send_scsi_cbw_out(int scsi_cmd, scsi_transfer * info)
231 {
232 /* URB to be send */
233 struct ddekit_usb_urb urb;
234
235 /* CBW data buffer */
236 mass_storage_cbw cbw;
237
238 MASS_DEBUG_DUMP;
239
240 /* Reset URB and assign given values */
241 init_urb(&urb, driver_state.cur_periph->dev,
242 &(driver_state.cur_periph->ep_out));
243
244 /* Reset CBW and assign default values */
245 init_cbw(&cbw, last_cbw_tag = current_cbw_tag++);
246
247 /* Fill CBW with SCSI command */
248 if (create_scsi_cmd(&cbw, scsi_cmd, info))
249 return EXIT_FAILURE;
250
251 /* Attach CBW to URB */
252 attach_urb_data(&urb, URB_BUF_TYPE_DATA, &cbw, sizeof(cbw));
253
254 /* Send and wait for response */
255 if (blocking_urb_submit(&urb, mass_storage_sem, URB_SUBMIT_CHECK_LEN))
256 return EXIT_FAILURE;
257
258 return EXIT_SUCCESS;
259 }
260
261
262 /*===========================================================================*
263 * mass_storage_send_scsi_data_in *
264 *===========================================================================*/
265 static int
266 mass_storage_send_scsi_data_in(void * buf, unsigned int in_len)
267 {
268 /* URB to be send */
269 struct ddekit_usb_urb urb;
270
271 MASS_DEBUG_DUMP;
272
273 /* Reset URB and assign given values */
274 init_urb(&urb, driver_state.cur_periph->dev,
275 &(driver_state.cur_periph->ep_in));
276
277 /* Attach buffer to URB */
278 attach_urb_data(&urb, URB_BUF_TYPE_DATA, buf, in_len);
279
280 /* Send and wait for response */
281 if (blocking_urb_submit(&urb, mass_storage_sem, URB_SUBMIT_CHECK_LEN))
282 return EXIT_FAILURE;
283
284 return EXIT_SUCCESS;
285 }
286
287
288 /*===========================================================================*
289 * mass_storage_send_scsi_data_out *
290 *===========================================================================*/
291 static int
292 mass_storage_send_scsi_data_out(void * buf, unsigned int out_len)
293 {
294 /* URB to be send */
295 struct ddekit_usb_urb urb;
296
297 MASS_DEBUG_DUMP;
298
299 /* Reset URB and assign given values */
300 init_urb(&urb, driver_state.cur_periph->dev,
301 &(driver_state.cur_periph->ep_out));
302
303 /* Attach buffer to URB */
304 attach_urb_data(&urb, URB_BUF_TYPE_DATA, buf, out_len);
305
306 /* Send and wait for response */
307 if (blocking_urb_submit(&urb, mass_storage_sem, URB_SUBMIT_CHECK_LEN))
308 return EXIT_FAILURE;
309
310 return EXIT_SUCCESS;
311 }
312
313
314 /*===========================================================================*
315 * mass_storage_send_scsi_csw_in *
316 *===========================================================================*/
317 static int
318 mass_storage_send_scsi_csw_in(void)
319 {
320 /* URB to be send */
321 struct ddekit_usb_urb urb;
322
323 /* CBW data buffer */
324 mass_storage_csw csw;
325
326 MASS_DEBUG_DUMP;
327
328 /* Reset URB and assign given values */
329 init_urb(&urb, driver_state.cur_periph->dev,
330 &(driver_state.cur_periph->ep_in));
331
332 /* Clear CSW for receiving */
333 init_csw(&csw);
334
335 /* Attach CSW to URB */
336 attach_urb_data(&urb, URB_BUF_TYPE_DATA, &csw, sizeof(csw));
337
338 /* Send and wait for response */
339 if (blocking_urb_submit(&urb, mass_storage_sem, URB_SUBMIT_CHECK_LEN))
340 return EXIT_FAILURE;
341
342 /* Check for proper reply */
343 if (check_csw(&csw, last_cbw_tag))
344 return EXIT_FAILURE;
345
346 return EXIT_SUCCESS;
347 }
348
349
350 #ifdef MASS_RESET_RECOVERY
351 /*===========================================================================*
352 * mass_storage_reset_recovery *
353 *===========================================================================*/
354 static int
355 mass_storage_reset_recovery(void)
356 {
357 MASS_DEBUG_DUMP;
358
359 /* Bulk-Only Mass Storage Reset */
360 if (mass_storage_send_bulk_reset()) {
361 MASS_MSG("Bulk-only mass storage reset failed");
362 return EIO;
363 }
364
365 /* Clear Feature HALT to the Bulk-In endpoint */
366 if (URB_INVALID_EP != driver_state.cur_periph->ep_in.ep_num)
367 if (mass_storage_send_clear_feature(
368 driver_state.cur_periph->ep_in.ep_num,
369 DDEKIT_USB_IN)) {
370 MASS_MSG("Resetting IN EP failed");
371 return EIO;
372 }
373
374 /* Clear Feature HALT to the Bulk-Out endpoint */
375 if (URB_INVALID_EP != driver_state.cur_periph->ep_out.ep_num)
376 if (mass_storage_send_clear_feature(
377 driver_state.cur_periph->ep_out.ep_num,
378 DDEKIT_USB_OUT)) {
379 MASS_MSG("Resetting OUT EP failed");
380 return EIO;
381 }
382
383 return EXIT_SUCCESS;
384 }
385
386
387 /*===========================================================================*
388 * mass_storage_send_bulk_reset *
389 *===========================================================================*/
390 static int
391 mass_storage_send_bulk_reset(void)
392 {
393 /* URB to be send */
394 struct ddekit_usb_urb urb;
395
396 /* Setup buffer to be send */
397 struct usb_ctrlrequest bulk_setup;
398
399 /* Control EP configuration */
400 urb_ep_config ep_conf;
401
402 MASS_DEBUG_DUMP;
403
404 /* Initialize EP configuration */
405 ep_conf.ep_num = 0;
406 ep_conf.direction = DDEKIT_USB_OUT;
407 ep_conf.type = DDEKIT_USB_TRANSFER_CTL;
408 ep_conf.max_packet_size = 0;
409 ep_conf.interval = 0;
410
411 /* Reset URB and assign given values */
412 init_urb(&urb, driver_state.cur_periph->dev, &ep_conf);
413
414 /* Clear setup data */
415 memset(&bulk_setup, 0, sizeof(bulk_setup));
416
417 /* For explanation of these values see usbmassbulk_10.pdf */
418 /* 3.1 Bulk-Only Mass Storage Reset */
419 bulk_setup.bRequestType = 0x21; /* Class, Interface, host to device */
420 bulk_setup.bRequest = 0xff;
421 bulk_setup.wValue = 0x00;
422 bulk_setup.wIndex = 0x00; /* TODO: hard-coded interface 0 */
423 bulk_setup.wLength = 0x00;
424
425 /* Attach request to URB */
426 attach_urb_data(&urb, URB_BUF_TYPE_SETUP,
427 &bulk_setup, sizeof(bulk_setup));
428
429 /* Send and wait for response */
430 if (blocking_urb_submit(&urb, mass_storage_sem, URB_SUBMIT_CHECK_LEN))
431 return EXIT_FAILURE;
432
433 return EXIT_SUCCESS;
434 }
435
436
437 /*===========================================================================*
438 * mass_storage_send_clear_feature *
439 *===========================================================================*/
440 static int
441 mass_storage_send_clear_feature(int ep_num, int direction)
442 {
443 /* URB to be send */
444 struct ddekit_usb_urb urb;
445
446 /* Setup buffer to be send */
447 struct usb_ctrlrequest bulk_setup;
448
449 /* Control EP configuration */
450 urb_ep_config ep_conf;
451
452 MASS_DEBUG_DUMP;
453
454 assert((ep_num >= 0) && (ep_num < 16));
455 assert((DDEKIT_USB_OUT == direction) || (DDEKIT_USB_IN == direction));
456
457 /* Initialize EP configuration */
458 ep_conf.ep_num = 0;
459 ep_conf.direction = DDEKIT_USB_OUT;
460 ep_conf.type = DDEKIT_USB_TRANSFER_CTL;
461 ep_conf.max_packet_size = 0;
462 ep_conf.interval = 0;
463
464 /* Reset URB and assign given values */
465 init_urb(&urb, driver_state.cur_periph->dev, &ep_conf);
466
467 /* Clear setup data */
468 memset(&bulk_setup, 0, sizeof(bulk_setup));
469
470 /* For explanation of these values see usbmassbulk_10.pdf */
471 /* 3.1 Bulk-Only Mass Storage Reset */
472 bulk_setup.bRequestType = 0x02; /* Standard, Endpoint, host to device */
473 bulk_setup.bRequest = 0x01; /* CLEAR_FEATURE */
474 bulk_setup.wValue = 0x00; /* Endpoint */
475 bulk_setup.wIndex = ep_num; /* Endpoint number... */
476 if (DDEKIT_USB_IN == direction)
477 bulk_setup.wIndex |= UE_DIR_IN; /* ...and direction bit */
478 bulk_setup.wLength = 0x00;
479
480 /* Attach request to URB */
481 attach_urb_data(&urb, URB_BUF_TYPE_SETUP,
482 &bulk_setup, sizeof(bulk_setup));
483
484 /* Send and wait for response */
485 if (blocking_urb_submit(&urb, mass_storage_sem, URB_SUBMIT_CHECK_LEN))
486 return EXIT_FAILURE;
487
488 return EXIT_SUCCESS;
489 }
490 #endif
491
492
493 /*===========================================================================*
494 * mass_storage_sef_hdlr *
495 *===========================================================================*/
496 static int
497 mass_storage_sef_hdlr(int type, sef_init_info_t * UNUSED(info))
498 {
499 int env_res;
500
501 MASS_DEBUG_DUMP;
502
503 /* Parse given environment */
504 env_res = env_parse("instance", "d", 0,
505 &(driver_state.instance),0, 255);
506
507 /* Get instance number */
508 if (EP_UNSET == env_res) {
509 MASS_DEBUG_MSG("Instance number was not supplied");
510 driver_state.instance = 0;
511 } else {
512 /* Only SET and UNSET are allowed */
513 if (EP_SET != env_res)
514 return EXIT_FAILURE;
515 }
516
517 switch (type) {
518 case SEF_INIT_FRESH:
519 /* Announce we are up! */
520 blockdriver_announce(type);
521 return EXIT_SUCCESS;
522 case SEF_INIT_LU:
523 case SEF_INIT_RESTART:
524 MASS_MSG("Only 'fresh' SEF initialization supported\n");
525 break;
526 default:
527 MASS_MSG("illegal SEF type\n");
528 break;
529 }
530
531 return EXIT_FAILURE;
532 }
533
534
535 /*===========================================================================*
536 * mass_storage_signal_handler *
537 *===========================================================================*/
538 static void
539 mass_storage_signal_handler(int this_signal)
540 {
541 MASS_DEBUG_DUMP;
542
543 #ifdef USB_STORAGE_SIGNAL
544 /* Only check for termination signal, ignore anything else. */
545 if (this_signal != SIGTERM)
546 return;
547 #else
548 MASS_MSG("Handling signal 0x%X", this_signal);
549 #endif
550
551 /* Try graceful DDEKit exit */
552 ddekit_shutdown();
553
554 /* Unreachable, when ddekit_shutdown works correctly */
555 panic("Calling ddekit_shutdown failed!");
556 }
557
558
559 /*===========================================================================*
560 * ddekit_usb_task *
561 *===========================================================================*/
562 static void
563 ddekit_usb_task(void * UNUSED(arg))
564 {
565 MASS_DEBUG_DUMP;
566
567 /* TODO: This call was meant to return 'int' but loops forever instead,
568 * so no return value is checked */
569 ddekit_usb_init(&mass_storage_driver, NULL, NULL);
570 }
571
572
573 /*===========================================================================*
574 * mass_storage_task *
575 *===========================================================================*/
576 static void
577 mass_storage_task(void * UNUSED(unused))
578 {
579 message m;
580 int ipc_status;
581 struct ddekit_minix_msg_q * mq;
582
583 MASS_DEBUG_DUMP;
584
585 mq = ddekit_minix_create_msg_q(BDEV_RQ_BASE, BDEV_RQ_BASE + 0xff);
586
587 for (;;) {
588 ddekit_minix_rcv(mq, &m, &ipc_status);
589 blockdriver_process(&mass_storage, &m, ipc_status);
590 }
591 }
592
593
594 /*===========================================================================*
595 * mass_storage_test *
596 *===========================================================================*/
597 static int
598 mass_storage_test(void)
599 {
600 int repeat;
601 int error;
602
603 struct timespec test_wait;
604
605 MASS_DEBUG_DUMP;
606
607 /* Delay between consecutive test commands, in case of their failure */
608 test_wait.tv_nsec = NEXT_TEST_DELAY;
609 test_wait.tv_sec = 0;
610
611 for (repeat = 0; repeat < MAX_TEST_RETRIES; repeat++) {
612
613 /* SCSI TEST UNIT READY OUT stage */
614 if (mass_storage_send_scsi_cbw_out(SCSI_TEST_UNIT_READY, NULL))
615 return EIO;
616
617 /* TODO: Only CSW failure should normally contribute to retry */
618
619 /* SCSI TEST UNIT READY IN stage */
620 if (EXIT_SUCCESS == mass_storage_send_scsi_csw_in())
621 return EXIT_SUCCESS;
622
623 /* Check for errors */
624 if (EXIT_SUCCESS != (error = mass_storage_check_error())) {
625 MASS_MSG("SCSI sense error checking failed");
626 return error;
627 }
628
629 /* Ignore potential signal interruption (no return value check),
630 * since it causes driver termination anyway */
631 if (nanosleep(&test_wait, NULL))
632 MASS_MSG("Calling nanosleep() failed");
633 }
634
635 return EIO;
636 }
637
638
639 /*===========================================================================*
640 * mass_storage_check_error *
641 *===========================================================================*/
642 static int
643 mass_storage_check_error(void)
644 {
645 /* SCSI sense structure for local use */
646 typedef struct MASS_PACKED scsi_sense {
647
648 uint8_t code : 7;
649 uint8_t valid : 1;
650 uint8_t obsolete : 8;
651 uint8_t sense : 4;
652 uint8_t reserved : 1;
653 uint8_t ili : 1;
654 uint8_t eom : 1;
655 uint8_t filemark : 1;
656 uint32_t information : 32;
657 uint8_t additional_len : 8;
658 uint32_t command_specific : 32;
659 uint8_t additional_code : 8;
660 uint8_t additional_qual : 8;
661 uint8_t unit_code : 8;
662 uint8_t key_specific1 : 7;
663 uint8_t sksv : 1;
664 uint16_t key_specific2 : 16;
665 }
666 scsi_sense;
667
668 /* Sense variable to hold received data */
669 scsi_sense sense;
670
671 MASS_DEBUG_DUMP;
672
673 /* Check if bit-fields are packed correctly */
674 __CTASSERT(sizeof(sense) == SCSI_REQUEST_SENSE_DATA_LEN);
675
676 /* SCSI REQUEST SENSE OUT stage */
677 if (mass_storage_send_scsi_cbw_out(SCSI_REQUEST_SENSE, NULL))
678 return EIO;
679
680 /* SCSI REQUEST SENSE first IN stage */
681 if (mass_storage_send_scsi_data_in(&sense, sizeof(sense)))
682 return EIO;
683
684 /* SCSI REQUEST SENSE second IN stage */
685 if (mass_storage_send_scsi_csw_in())
686 return EIO;
687
688 /* When any sense code is present something may have failed */
689 if (sense.sense) {
690 #ifdef MASS_DEBUG
691 MASS_MSG("SCSI sense: ");
692 MASS_MSG("code : %8X", sense.code );
693 MASS_MSG("valid : %8X", sense.valid );
694 MASS_MSG("obsolete : %8X", sense.obsolete );
695 MASS_MSG("sense : %8X", sense.sense );
696 MASS_MSG("reserved : %8X", sense.reserved );
697 MASS_MSG("ili : %8X", sense.ili );
698 MASS_MSG("eom : %8X", sense.eom );
699 MASS_MSG("filemark : %8X", sense.filemark );
700 MASS_MSG("information : %8X", sense.information );
701 MASS_MSG("additional_len : %8X", sense.additional_len );
702 MASS_MSG("command_specific : %8X", sense.command_specific);
703 MASS_MSG("additional_code : %8X", sense.additional_code );
704 MASS_MSG("additional_qual : %8X", sense.additional_qual );
705 MASS_MSG("unit_code : %8X", sense.unit_code );
706 MASS_MSG("key_specific1 : %8X", sense.key_specific1 );
707 MASS_MSG("sksv : %8X", sense.sksv );
708 MASS_MSG("key_specific2 : %8X", sense.key_specific2 );
709 #else
710 MASS_MSG("SCSI sense: 0x%02X 0x%02X 0x%02X", sense.sense,
711 sense.additional_code, sense.additional_qual);
712 #endif
713 }
714
715 return EXIT_SUCCESS;
716 }
717
718
719 /*===========================================================================*
720 * mass_storage_try_first_open *
721 *===========================================================================*/
722 static int
723 mass_storage_try_first_open()
724 {
725 unsigned int llba;
726 unsigned int blen;
727 unsigned char inquiry[SCSI_INQUIRY_DATA_LEN];
728 unsigned char capacity[SCSI_READ_CAPACITY_DATA_LEN];
729
730 MASS_DEBUG_DUMP;
731
732 assert(NULL != driver_state.cur_drive);
733
734 llba = 0; /* Last logical block address */
735 blen = 0; /* Block length (usually 512B) */
736
737 /* Run TEST UNIT READY before other SCSI command
738 * Some devices refuse to work without this */
739 if (mass_storage_test())
740 return EIO;
741
742 /* SCSI INQUIRY OUT stage */
743 if (mass_storage_send_scsi_cbw_out(SCSI_INQUIRY, NULL))
744 return EIO;
745
746 /* SCSI INQUIRY first IN stage */
747 if (mass_storage_send_scsi_data_in(inquiry, sizeof(inquiry)))
748 return EIO;
749
750 /* SCSI INQUIRY second IN stage */
751 if (mass_storage_send_scsi_csw_in())
752 return EIO;
753
754 /* Check for proper reply */
755 if (check_inquiry_reply(inquiry))
756 return EIO;
757
758 /* Run TEST UNIT READY before other SCSI command
759 * Some devices refuse to work without this */
760 if (mass_storage_test())
761 return EIO;
762
763 /* SCSI READ CAPACITY OUT stage */
764 if (mass_storage_send_scsi_cbw_out(SCSI_READ_CAPACITY, NULL))
765 return EIO;
766
767 /* SCSI READ CAPACITY first IN stage */
768 if (mass_storage_send_scsi_data_in(capacity, sizeof(capacity)))
769 return EIO;
770
771 /* SCSI READ CAPACITY second IN stage */
772 if (mass_storage_send_scsi_csw_in())
773 return EIO;
774
775 /* Check for proper reply */
776 if (check_read_capacity_reply(capacity, &llba, &blen))
777 return EIO;
778
779 /* For now only Minix's default SECTOR_SIZE is supported */
780 if (SECTOR_SIZE != blen)
781 panic("Invalid block size used by USB device!");
782
783 /* Get information about capacity from reply */
784 driver_state.cur_drive->disk.dv_base = 0;
785 driver_state.cur_drive->disk.dv_size = llba * blen;
786
787 return EXIT_SUCCESS;
788 }
789
790
791 /*===========================================================================*
792 * mass_storage_transfer_restrictions *
793 *===========================================================================*/
794 static int
795 mass_storage_transfer_restrictions(u64_t pos, unsigned long bytes)
796 {
797 MASS_DEBUG_DUMP;
798
799 assert(NULL != driver_state.cur_device);
800
801 /* Zero-length request must not be issued */
802 if (0 == bytes) {
803 MASS_MSG("Transfer request length equals 0");
804 return EINVAL;
805 }
806
807 /* Starting position must be aligned to sector */
808 if (0 != (pos % SECTOR_SIZE)) {
809 MASS_MSG("Transfer position not divisible by %u", SECTOR_SIZE);
810 return EINVAL;
811 }
812
813 /* Length must be integer multiple of sector sizes */
814 if (0 != (bytes % SECTOR_SIZE)) {
815 MASS_MSG("Data length not divisible by %u", SECTOR_SIZE);
816 return EINVAL;
817 }
818
819 /* Guard against ridiculous 64B overflow */
820 if ((pos + bytes) <= pos) {
821 MASS_MSG("Request outside available address space");
822 return EINVAL;
823 }
824
825 return EXIT_SUCCESS;
826 }
827
828
829 /*===========================================================================*
830 * mass_storage_write *
831 *===========================================================================*/
832 static ssize_t
833 mass_storage_write(unsigned long sector_number,
834 endpoint_t endpt,
835 iovec_t * iov,
836 unsigned int iov_count,
837 unsigned long bytes_left)
838 {
839 /*
840 * This function writes whatever was put in 'iov' array
841 * (iov[0] : iov[iov_count]), into continuous region of mass storage,
842 * starting from sector 'sector_number'. Total amount of 'iov'
843 * data should be greater or equal to initial value of 'bytes_left'.
844 *
845 * Endpoint value 'endpt', determines if vectors 'iov' contain memory
846 * addresses for copying or grant IDs.
847 */
848
849 iov_state cur_iov; /* Current state of vector copying */
850 unsigned long bytes_to_write; /* To be written in this iteration */
851 ssize_t bytes_already_written; /* Total amount written (retval) */
852
853 MASS_DEBUG_DUMP;
854
855 /* Initialize locals */
856 cur_iov.remaining_bytes = 0; /* No IO vector initially */
857 cur_iov.iov_idx = 0; /* Starting from first vector */
858 bytes_already_written = 0; /* Nothing copied yet */
859
860 /* Mass storage operations are sector based */
861 assert(0 == (sizeof(buffer) % SECTOR_SIZE));
862 assert(0 == (bytes_left % SECTOR_SIZE));
863
864 while (bytes_left > 0) {
865
866 /* Fill write buffer with data from IO Vectors */
867 {
868 unsigned long buf_offset;
869 unsigned long copy_len;
870
871 /* Start copying to the beginning of the buffer */
872 buf_offset = 0;
873
874 /* Copy as long as not copied vectors exist or
875 * buffer is not fully filled */
876 for (;;) {
877
878 /* If entire previous vector
879 * was used get new one */
880 if (0 == cur_iov.remaining_bytes) {
881 /* Check if there are
882 * vectors to copied */
883 if (cur_iov.iov_idx < iov_count) {
884
885 cur_iov.base_addr =
886 iov[cur_iov.iov_idx].iov_addr;
887 cur_iov.remaining_bytes =
888 iov[cur_iov.iov_idx].iov_size;
889 cur_iov.offset = 0;
890 cur_iov.iov_idx++;
891
892 } else {
893 /* All vectors copied */
894 break;
895 }
896 }
897
898 /* Copy as much as it is possible from vector
899 * and at most the amount that can be
900 * put in buffer */
901 copy_len = MIN(sizeof(buffer) - buf_offset,
902 cur_iov.remaining_bytes);
903
904 /* This distinction is required as transfer can
905 * be used from within this process and meaning
906 * of IO vector'a address is different than
907 * grant ID */
908 if (endpt == SELF) {
909 memcpy(&buffer[buf_offset],
910 (void*)(cur_iov.base_addr +
911 cur_iov.offset), copy_len);
912 } else {
913 ssize_t copy_res;
914 if ((copy_res = sys_safecopyfrom(endpt,
915 cur_iov.base_addr,
916 cur_iov.offset,
917 (vir_bytes)
918 (&buffer[buf_offset]),
919 copy_len))) {
920 MASS_MSG("sys_safecopyfrom "
921 "failed");
922 return copy_res;
923 }
924 }
925
926 /* Alter current state of copying */
927 buf_offset += copy_len;
928 cur_iov.offset += copy_len;
929 cur_iov.remaining_bytes -= copy_len;
930
931 /* Buffer was filled */
932 if (sizeof(buffer) == buf_offset)
933 break;
934 }
935
936 /* Determine how many bytes from copied buffer we wish
937 * to write, buf_offset represents total amount of
938 * bytes copied above */
939 if (bytes_left >= buf_offset) {
940 bytes_to_write = buf_offset;
941 bytes_left -= buf_offset;
942 } else {
943 bytes_to_write = bytes_left;
944 bytes_left = 0;
945 }
946 }
947
948 /* Send URB and alter sector number */
949 if (bytes_to_write > 0) {
950
951 scsi_transfer info;
952
953 info.length = bytes_to_write;
954 info.lba = sector_number;
955
956 /* SCSI WRITE first OUT stage */
957 if (mass_storage_send_scsi_cbw_out(SCSI_WRITE, &info))
958 return EIO;
959
960 /* SCSI WRITE second OUT stage */
961 if (mass_storage_send_scsi_data_out(buffer,
962 bytes_to_write))
963 return EIO;
964
965 /* SCSI WRITE IN stage */
966 if (mass_storage_send_scsi_csw_in())
967 return EIO;
968
969 /* Writing completed so shift starting
970 * sector for next iteration */
971 sector_number += bytes_to_write / SECTOR_SIZE;
972
973 /* Update amount of data already copied */
974 bytes_already_written += bytes_to_write;
975 }
976 }
977
978 return bytes_already_written;
979 }
980
981
982 /*===========================================================================*
983 * mass_storage_read *
984 *===========================================================================*/
985 static ssize_t
986 mass_storage_read(unsigned long sector_number,
987 endpoint_t endpt,
988 iovec_t * iov,
989 unsigned int iov_count,
990 unsigned long bytes_left)
991 {
992 /*
993 * This function reads 'bytes_left' bytes of mass storage data into
994 * 'iov' array (iov[0] : iov[iov_count]) starting from sector
995 * 'sector_number'. Total amount of 'iov' data should be greater or
996 * equal to initial value of 'bytes_left'.
997 *
998 * Endpoint value 'endpt', determines if vectors 'iov' contain memory
999 * addresses for copying or grant IDs.
1000 */
1001
1002 iov_state cur_iov; /* Current state of vector copying */
1003 unsigned long bytes_to_read; /* To be read in this iteration */
1004 ssize_t bytes_already_read; /* Total amount read (retval) */
1005
1006 MASS_DEBUG_DUMP;
1007
1008 /* Initialize locals */
1009 cur_iov.remaining_bytes = 0; /* No IO vector initially */
1010 cur_iov.iov_idx = 0; /* Starting from first vector */
1011 bytes_already_read = 0; /* Nothing copied yet */
1012
1013 /* Mass storage operations are sector based */
1014 assert(0 == (sizeof(buffer) % SECTOR_SIZE));
1015 assert(0 == (bytes_left % SECTOR_SIZE));
1016
1017 while (bytes_left > 0) {
1018
1019 /* Decide read length and alter remaining bytes */
1020 {
1021 /* Number of bytes to be read in next URB */
1022 if (bytes_left > sizeof(buffer)) {
1023 bytes_to_read = sizeof(buffer);
1024 } else {
1025 bytes_to_read = bytes_left;
1026 }
1027
1028 bytes_left -= bytes_to_read;
1029 }
1030
1031 /* Send URB and alter sector number */
1032 {
1033 scsi_transfer info;
1034
1035 info.length = bytes_to_read;
1036 info.lba = sector_number;
1037
1038 /* SCSI READ OUT stage */
1039 if (mass_storage_send_scsi_cbw_out(SCSI_READ, &info))
1040 return EIO;
1041
1042 /* SCSI READ first IN stage */
1043 if (mass_storage_send_scsi_data_in(buffer,
1044 bytes_to_read))
1045 return EIO;
1046
1047 /* SCSI READ second IN stage */
1048 if (mass_storage_send_scsi_csw_in())
1049 return EIO;
1050
1051 /* Reading completed so shift starting
1052 * sector for next iteration */
1053 sector_number += bytes_to_read / SECTOR_SIZE;
1054 }
1055
1056 /* Fill IO Vectors with data from buffer */
1057 {
1058 unsigned long buf_offset;
1059 unsigned long copy_len;
1060
1061 /* Start copying from the beginning of the buffer */
1062 buf_offset = 0;
1063
1064 /* Copy as long as there are unfilled vectors
1065 * or data in buffer remains */
1066 for (;;) {
1067
1068 /* If previous vector was filled get new one */
1069 if (0 == cur_iov.remaining_bytes) {
1070 /* Check if there are vectors
1071 * to be filled */
1072 if (cur_iov.iov_idx < iov_count) {
1073
1074 cur_iov.base_addr =
1075 iov[cur_iov.iov_idx].iov_addr;
1076 cur_iov.remaining_bytes =
1077 iov[cur_iov.iov_idx].iov_size;
1078 cur_iov.offset = 0;
1079 cur_iov.iov_idx++;
1080
1081 } else {
1082 /* Total length of vectors
1083 * should be greater or equal
1084 * to initial value of
1085 * bytes_left. Being here means
1086 * that everything should
1087 * have been copied already */
1088 assert(0 == bytes_left);
1089 break;
1090 }
1091 }
1092
1093 /* Copy as much as it is possible from buffer
1094 * and at most the amount that can be
1095 * put in vector */
1096 copy_len = MIN(bytes_to_read - buf_offset,
1097 cur_iov.remaining_bytes);
1098
1099 /* This distinction is required as transfer can
1100 * be used from within this process and meaning
1101 * of IO vector'a address is different than
1102 * grant ID */
1103 if (endpt == SELF) {
1104 memcpy((void*)(cur_iov.base_addr +
1105 cur_iov.offset),
1106 &buffer[buf_offset],
1107 copy_len);
1108 } else {
1109 ssize_t copy_res;
1110 if ((copy_res = sys_safecopyto(endpt,
1111 cur_iov.base_addr,
1112 cur_iov.offset,
1113 (vir_bytes)
1114 (&buffer[buf_offset]),
1115 copy_len))) {
1116 MASS_MSG("sys_safecopyto "
1117 "failed");
1118 return copy_res;
1119 }
1120 }
1121
1122 /* Alter current state of copying */
1123 buf_offset += copy_len;
1124 cur_iov.offset += copy_len;
1125 cur_iov.remaining_bytes -= copy_len;
1126
1127 /* Everything was copied */
1128 if (bytes_to_read == buf_offset)
1129 break;
1130 }
1131
1132 /* Update amount of data already copied */
1133 bytes_already_read += buf_offset;
1134 }
1135 }
1136
1137 return bytes_already_read;
1138 }
1139
1140
1141 /*===========================================================================*
1142 * mass_storage_open *
1143 *===========================================================================*/
1144 static int
1145 mass_storage_open(devminor_t minor, int UNUSED(access))
1146 {
1147 mass_storage_drive * d;
1148 int r;
1149
1150 MASS_DEBUG_DUMP;
1151
1152 /* Decode minor into drive device information */
1153 if (NULL == (mass_storage_part(minor)))
1154 return ENXIO;
1155
1156 /* Copy evaluated current drive for simplified dereference */
1157 d = driver_state.cur_drive;
1158
1159 #ifdef MASS_RESET_RECOVERY
1160 /* In case of previous CBW mismatch */
1161 if (mass_storage_reset_recovery()) {
1162 MASS_MSG("Resetting mass storage device failed");
1163 return EIO;
1164 }
1165 #endif
1166
1167 /* In case of missing endpoint information, do simple
1168 * enumeration and hold it for future use */
1169 if ((URB_INVALID_EP == driver_state.cur_periph->ep_in.ep_num) ||
1170 (URB_INVALID_EP == driver_state.cur_periph->ep_out.ep_num)) {
1171
1172 if (mass_storage_get_endpoints(&driver_state.cur_periph->ep_in,
1173 &driver_state.cur_periph->ep_out))
1174 return EIO;
1175 }
1176
1177 /* If drive hasn't been opened yet, try to open it */
1178 if (d->open_ct == 0) {
1179 if ((r = mass_storage_try_first_open())) {
1180 MASS_MSG("Opening mass storage device"
1181 " for the first time failed");
1182
1183 /* Do one more test before failing, to output
1184 * sense errors in case they weren't dumped already */
1185 if (mass_storage_test())
1186 MASS_MSG("Final TEST UNIT READY failed");
1187
1188 return r;
1189 }
1190
1191 /* Clear remembered device state for current
1192 * drive before calling partition */
1193 memset(&d->part[0], 0, sizeof(d->part));
1194 memset(&d->subpart[0], 0, sizeof(d->subpart));
1195
1196 /* Try parsing partition table (for entire drive) */
1197 /* Warning!! This call uses mass_storage_part with own minors
1198 * and alters global driver_state.cur_device! */
1199 partition(&mass_storage, (d->drive_idx * DEV_PER_DRIVE),
1200 P_PRIMARY, 0);
1201
1202 /* Decode minor into UPDATED drive device information */
1203 if (NULL == (mass_storage_part(minor)))
1204 return ENXIO;
1205
1206 /* Decoded size must be positive or else
1207 * we assume device (partition) is unavailable */
1208 if (0 == driver_state.cur_device->dv_size)
1209 return ENXIO;
1210 }
1211
1212 /* Run TEST UNIT READY before further commands
1213 * Some devices refuse to work without this */
1214 if (mass_storage_test())
1215 return EIO;
1216
1217 /* Opening completed */
1218 d->open_ct++;
1219
1220 return EXIT_SUCCESS;
1221 }
1222
1223
1224 /*===========================================================================*
1225 * mass_storage_close *
1226 *===========================================================================*/
1227 static int mass_storage_close(devminor_t minor)
1228 {
1229 MASS_DEBUG_DUMP;
1230
1231 /* Decode minor into drive device information */
1232 if (NULL == (mass_storage_part(minor)))
1233 return ENXIO;
1234
1235 /* If drive hasn't been opened yet */
1236 if (driver_state.cur_drive->open_ct == 0) {
1237 MASS_MSG("Device was not opened yet");
1238 return ERESTART;
1239 }
1240
1241 /* Act accordingly */
1242 driver_state.cur_drive->open_ct--;
1243
1244 return EXIT_SUCCESS;
1245 }
1246
1247
1248 /*===========================================================================*
1249 * mass_storage_transfer *
1250 *===========================================================================*/
1251 static ssize_t
1252 mass_storage_transfer(devminor_t minor, /* device minor number */
1253 int do_write, /* 1 write, 0 read */
1254 u64_t pos, /* position of starting point */
1255 endpoint_t endpt, /* endpoint */
1256 iovec_t * iov, /* vector */
1257 unsigned int iov_count, /* how many vectors */
1258 int UNUSED(flags)) /* transfer flags */
1259 {
1260 u64_t temp_sector_number;
1261 unsigned long bytes;
1262 unsigned long sector_number;
1263 unsigned int cur_iov_idx;
1264 int r;
1265
1266 MASS_DEBUG_DUMP;
1267
1268 /* Decode minor into drive device information */
1269 if (NULL == (mass_storage_part(minor)))
1270 return ENXIO;
1271
1272 bytes = 0;
1273
1274 /* How much data is going to be transferred? */
1275 for (cur_iov_idx = 0; cur_iov_idx < iov_count; ++cur_iov_idx) {
1276
1277 /* Check if grant ID was supplied
1278 * instead of address and if it is valid */
1279 if (endpt != SELF)
1280 if (!GRANT_VALID((cp_grant_id_t)
1281 (iov[cur_iov_idx].iov_addr)))
1282 return EINVAL;
1283
1284 /* All supplied vectors must have positive length */
1285 if ((signed long)(iov[cur_iov_idx].iov_size) <= 0) {
1286 MASS_MSG("Transfer request length is not positive");
1287 return EINVAL;
1288 }
1289
1290 /* Requirements were met, more bytes can be transferred */
1291 bytes += iov[cur_iov_idx].iov_size;
1292
1293 /* Request size must never overflow */
1294 if ((signed long)bytes <= 0) {
1295 MASS_MSG("Transfer request length overflowed");
1296 return EINVAL;
1297 }
1298 }
1299
1300 /* Check if reading beyond device/partition */
1301 if (pos >= driver_state.cur_device->dv_size) {
1302 MASS_MSG("Request out of bounds for given device");
1303 return 0; /* No error and no bytes read */
1304 }
1305
1306 /* Check if arguments agree with accepted restriction
1307 * for parameters of transfer */
1308 if ((r = mass_storage_transfer_restrictions(pos, bytes)))
1309 return r;
1310
1311 /* If 'hard' requirements above were met, do additional
1312 * limiting to device/partition boundary */
1313 if ((pos + bytes) > driver_state.cur_device->dv_size)
1314 bytes = (driver_state.cur_device->dv_size - pos) &
1315 ~SECTOR_MASK;
1316
1317 /* We have to obtain sector number of given position
1318 * and limit it to what URB can handle */
1319 temp_sector_number = (driver_state.cur_device->dv_base + pos) /
1320 SECTOR_SIZE;
1321 assert(temp_sector_number < ULONG_MAX); /* LBA is limited to 32B */
1322 sector_number = (unsigned long)temp_sector_number;
1323
1324 if (do_write)
1325 return mass_storage_write(sector_number, endpt, iov,
1326 iov_count, bytes);
1327 else
1328 return mass_storage_read(sector_number, endpt, iov,
1329 iov_count, bytes);
1330 }
1331
1332
1333 /*===========================================================================*
1334 * mass_storage_ioctl *
1335 *===========================================================================*/
1336 static int
1337 mass_storage_ioctl(devminor_t minor, unsigned long request, endpoint_t endpt,
1338 cp_grant_id_t grant, endpoint_t UNUSED(user_endpt))
1339 {
1340 MASS_DEBUG_DUMP;
1341
1342 /* Decode minor into drive device information */
1343 if (NULL == (mass_storage_part(minor)))
1344 return ENXIO;
1345
1346 switch (request) {
1347 case DIOCOPENCT:
1348 if (sys_safecopyto(endpt, grant, 0,
1349 (vir_bytes) &(driver_state.cur_drive->open_ct),
1350 sizeof(driver_state.cur_drive->open_ct)))
1351 panic("sys_safecopyto failed!");
1352
1353 return EXIT_SUCCESS;
1354
1355 default:
1356 MASS_MSG("Unimplemented IOCTL request: 0x%X",
1357 (int)request);
1358 break;
1359 }
1360
1361 return ENOTTY;
1362 }
1363
1364
1365 /*===========================================================================*
1366 * mass_storage_cleanup *
1367 *===========================================================================*/
1368 static void mass_storage_cleanup(void)
1369 {
1370 MASS_DEBUG_DUMP;
1371 return;
1372 }
1373
1374
1375 /*===========================================================================*
1376 * mass_storage_part *
1377 *===========================================================================*/
1378 static struct device *
1379 mass_storage_part(devminor_t minor)
1380 {
1381 unsigned long sel_drive;
1382 unsigned long sel_device;
1383
1384 MASS_DEBUG_DUMP;
1385
1386 /* Override every time before further decision */
1387 driver_state.cur_drive = NULL;
1388 driver_state.cur_device = NULL;
1389 driver_state.cur_periph = NULL;
1390
1391 /* Decode 'minor' code to find which device file was used */
1392 if (minor < MINOR_d0p0s0) {
1393
1394 /* No sub-partitions used */
1395 sel_drive = minor / DEV_PER_DRIVE;
1396 sel_device = minor % DEV_PER_DRIVE;
1397
1398 /* Only valid minors */
1399 if (sel_drive < MAX_DRIVES) {
1400 /* Associate minor (device/partition)
1401 * with peripheral number */
1402 /* TODO:PERIPH
1403 * Proper peripheral selection based
1404 * on minor should be here: */
1405 driver_state.cur_periph = &driver_state.periph[0];
1406
1407 /* Select drive entry for opening count etc. */
1408 driver_state.cur_drive =
1409 &(driver_state.cur_periph->drives[sel_drive]);
1410
1411 /* Select device entry for given device file */
1412 /* Device 0 means entire drive.
1413 * Devices 1,2,3,4 mean partitions 0,1,2,3 */
1414 if (0 == sel_device)
1415 driver_state.cur_device =
1416 &(driver_state.cur_drive->disk);
1417 else
1418 driver_state.cur_device =
1419 &(driver_state.cur_drive->part
1420 [sel_device-1]);
1421 }
1422
1423 } else {
1424
1425 /* Shift values accordingly */
1426 minor -= MINOR_d0p0s0;
1427
1428 /* Sub-partitions used */
1429 sel_drive = minor / SUBPART_PER_DISK;
1430 sel_device = minor % SUBPART_PER_DISK;
1431
1432 /* Only valid minors */
1433 if (sel_drive < MAX_DRIVES) {
1434 /* Leave in case of ridiculously high number */
1435 if (minor < SUBPART_PER_DISK) {
1436 /* Associate minor (device/partition)
1437 * with peripheral number */
1438 /* TODO:PERIPH
1439 * Proper peripheral selection based
1440 * on minor should be here: */
1441 driver_state.cur_periph =
1442 &driver_state.periph[0];
1443
1444 /* Select drive entry for opening count etc. */
1445 driver_state.cur_drive =
1446 &(driver_state.cur_periph->drives
1447 [sel_drive]);
1448 /* Select device entry for given
1449 * sub-partition device file */
1450 driver_state.cur_device =
1451 &(driver_state.cur_drive->subpart
1452 [sel_device]);
1453 }
1454 }
1455 }
1456
1457 /* Check for success */
1458 if (NULL == driver_state.cur_device) {
1459 MASS_MSG("Device for minor: %u not found", minor);
1460 } else {
1461 /* Assign index as well */
1462 driver_state.cur_drive->drive_idx = sel_drive;
1463 }
1464
1465 return driver_state.cur_device;
1466 }
1467
1468
1469 /*===========================================================================*
1470 * mass_storage_geometry *
1471 *===========================================================================*/
1472 /* This command is optional for most mass storage devices
1473 * It should rather be used with USB floppy disk reader */
1474 #ifdef MASS_USE_GEOMETRY
1475 static void
1476 mass_storage_geometry(devminor_t minor, struct part_geom * part)
1477 {
1478 char flexible_disk_page[SCSI_MODE_SENSE_FLEX_DATA_LEN];
1479
1480 MASS_DEBUG_DUMP;
1481
1482 /* Decode minor into drive device information */
1483 if (NULL == (mass_storage_part(minor)))
1484 return;
1485
1486 /* SCSI MODE SENSE OUT stage */
1487 if (mass_storage_send_scsi_cbw_out(SCSI_MODE_SENSE, NULL))
1488 return;
1489
1490 /* SCSI MODE SENSE first IN stage */
1491 if (mass_storage_send_scsi_data_in(flexible_disk_page,
1492 sizeof(flexible_disk_page)))
1493 return;
1494
1495 /* SCSI MODE SENSE second IN stage */
1496 if (mass_storage_send_scsi_csw_in())
1497 return;
1498
1499 /* Get geometry from reply */
1500 if (check_mode_sense_reply(flexible_disk_page, &(part->cylinders),
1501 &(part->heads), &(part->sectors)))
1502 return;
1503 #else
1504 static void
1505 mass_storage_geometry(devminor_t UNUSED(minor), struct part_geom * part)
1506 {
1507 MASS_DEBUG_DUMP;
1508
1509 part->cylinders = part->size / SECTOR_SIZE;
1510 part->heads = 64;
1511 part->sectors = 32;
1512 #endif
1513 }
1514
1515
1516 /*===========================================================================*
1517 * usb_driver_completion *
1518 *===========================================================================*/
1519 static void
1520 usb_driver_completion(void * UNUSED(priv))
1521 {
1522 /* Last request was completed so allow continuing
1523 * execution from place where semaphore was downed */
1524 ddekit_sem_up(mass_storage_sem);
1525 }
1526
1527
1528 /*===========================================================================*
1529 * usb_driver_connect *
1530 *===========================================================================*/
1531 static void
1532 usb_driver_connect(struct ddekit_usb_dev * dev,
1533 unsigned int interfaces)
1534 {
1535 MASS_DEBUG_DUMP;
1536
1537 /* TODO:PERIPH
1538 * Some sort of more complex peripheral assignment should be here */
1539 driver_state.cur_periph = &driver_state.periph[0];
1540
1541 if (NULL != driver_state.cur_periph->dev)
1542 panic("Only one peripheral can be connected!");
1543
1544 /* Hold host information for future use */
1545 driver_state.cur_periph->dev = dev;
1546 driver_state.cur_periph->interfaces = interfaces;
1547 driver_state.cur_periph->ep_in.ep_num = URB_INVALID_EP;
1548 driver_state.cur_periph->ep_out.ep_num = URB_INVALID_EP;
1549 }
1550
1551
1552 /*===========================================================================*
1553 * usb_driver_disconnect *
1554 *===========================================================================*/
1555 static void
1556 usb_driver_disconnect(struct ddekit_usb_dev * UNUSED(dev))
1557 {
1558 MASS_DEBUG_DUMP;
1559
1560 /* TODO:PERIPH
1561 * Some sort of peripheral discard should be here */
1562 driver_state.cur_periph = &driver_state.periph[0];
1563
1564 assert(NULL != driver_state.cur_periph->dev);
1565
1566 /* Clear */
1567 driver_state.cur_periph->dev = NULL;
1568 driver_state.cur_periph->interfaces = 0;
1569 driver_state.cur_periph->ep_in.ep_num = URB_INVALID_EP;
1570 driver_state.cur_periph->ep_out.ep_num = URB_INVALID_EP;
1571 }
1572
1573
1574 /*===========================================================================*
1575 * mass_storage_get_endpoints *
1576 *===========================================================================*/
1577 static int
1578 mass_storage_get_endpoints(urb_ep_config * ep_in, urb_ep_config * ep_out)
1579 {
1580 /* URB to be send */
1581 struct ddekit_usb_urb urb;
1582
1583 /* Setup buffer to be attached */
1584 struct usb_ctrlrequest setup_buf;
1585
1586 /* Control EP configuration */
1587 urb_ep_config ep_conf;
1588
1589 /* Descriptors' buffer */
1590 unsigned char descriptors[MAX_DESCRIPTORS_LEN];
1591
1592 MASS_DEBUG_DUMP;
1593
1594 /* Initialize EP configuration */
1595 ep_conf.ep_num = 0;
1596 ep_conf.direction = DDEKIT_USB_IN;
1597 ep_conf.type = DDEKIT_USB_TRANSFER_CTL;
1598 ep_conf.max_packet_size = 0;
1599 ep_conf.interval = 0;
1600
1601 /* Reset URB and assign given values */
1602 init_urb(&urb, driver_state.cur_periph->dev, &ep_conf);
1603
1604 /* Clear setup data */
1605 memset(&setup_buf, 0, sizeof(setup_buf));
1606
1607 /* Standard get endpoint request */
1608 setup_buf.bRequestType = 0x80; /* Device to host */
1609 setup_buf.bRequest = UR_GET_DESCRIPTOR;
1610 setup_buf.wValue = UDESC_CONFIG << 8; /* TODO: configuration 0 */
1611 setup_buf.wIndex = 0x00;
1612 setup_buf.wLength = MAX_DESCRIPTORS_LEN;
1613
1614 /* Attach buffers to URB */
1615 attach_urb_data(&urb, URB_BUF_TYPE_SETUP,
1616 &setup_buf, sizeof(setup_buf));
1617 attach_urb_data(&urb, URB_BUF_TYPE_DATA,
1618 descriptors, sizeof(descriptors));
1619
1620 /* Send and wait for response */
1621 if (blocking_urb_submit(&urb, mass_storage_sem,
1622 URB_SUBMIT_ALLOW_MISMATCH))
1623 return EXIT_FAILURE;
1624
1625 /* Check if buffer was supposed to hold more data */
1626 if (urb.size < urb.actual_length) {
1627 MASS_MSG("Too much descriptor data received");
1628 return EXIT_FAILURE;
1629 }
1630
1631 return mass_storage_parse_descriptors(urb.data, urb.actual_length,
1632 ep_in, ep_out);
1633 }
1634
1635
1636 /*===========================================================================*
1637 * mass_storage_parse_endpoint *
1638 *===========================================================================*/
1639 static int
1640 mass_storage_parse_endpoint(usb_descriptor_t * cur_desc,
1641 urb_ep_config * ep_in, urb_ep_config * ep_out)
1642 {
1643 usb_endpoint_descriptor_t * ep_desc;
1644
1645 urb_ep_config * this_ep;
1646
1647 MASS_DEBUG_DUMP;
1648
1649 ep_desc = (usb_endpoint_descriptor_t *)cur_desc;
1650
1651 /* Only bulk with no other attributes are important */
1652 if (UE_BULK == ep_desc->bmAttributes) {
1653
1654 /* Check for direction */
1655 if (UE_DIR_IN == UE_GET_DIR(ep_desc->bEndpointAddress)) {
1656
1657 this_ep = ep_in;
1658 this_ep->direction = DDEKIT_USB_IN;
1659
1660 } else {
1661
1662 this_ep = ep_out;
1663 this_ep->direction = DDEKIT_USB_OUT;
1664 }
1665
1666 /* Check if it was set before */
1667 if (URB_INVALID_EP != this_ep->ep_num) {
1668 MASS_MSG("BULK EP already set");
1669 return EXIT_FAILURE;
1670 }
1671
1672 /* Assign rest */
1673 this_ep->ep_num = UE_GET_ADDR(ep_desc->bEndpointAddress);
1674 this_ep->type = DDEKIT_USB_TRANSFER_BLK;
1675 this_ep->max_packet_size = UGETW(ep_desc->wMaxPacketSize);
1676 this_ep->interval = ep_desc->bInterval;
1677 }
1678
1679 /* EP type other than bulk, is also correct,
1680 * just no parsing is performed */
1681 return EXIT_SUCCESS;
1682 }
1683
1684 /*===========================================================================*
1685 * mass_storage_parse_descriptors *
1686 *===========================================================================*/
1687 static int
1688 mass_storage_parse_descriptors(char * desc_buf, unsigned int buf_len,
1689 urb_ep_config * ep_in, urb_ep_config * ep_out)
1690 {
1691 /* Currently parsed, descriptors */
1692 usb_descriptor_t * cur_desc;
1693 usb_interface_descriptor_t * ifc_desc;
1694
1695 /* Byte counter for descriptor parsing */
1696 unsigned int cur_byte;
1697
1698 /* Non zero if recently parsed interface is valid for this device */
1699 int valid_interface;
1700
1701 MASS_DEBUG_DUMP;
1702
1703 /* Parse descriptors to get endpoints */
1704 ep_in->ep_num = URB_INVALID_EP;
1705 ep_out->ep_num = URB_INVALID_EP;
1706 valid_interface = 0;
1707 cur_byte = 0;
1708
1709 while (cur_byte < buf_len) {
1710
1711 /* Map descriptor to buffer */
1712 /* Structure is packed so alignment should not matter */
1713 cur_desc = (usb_descriptor_t *)&(desc_buf[cur_byte]);
1714
1715 /* Check this so we won't be reading
1716 * memory outside the buffer */
1717 if ((cur_desc->bLength > 3) &&
1718 (cur_byte + cur_desc->bLength <= buf_len)) {
1719
1720 /* Parse based on descriptor type */
1721 switch (cur_desc->bDescriptorType) {
1722
1723 case UDESC_CONFIG: {
1724 if (USB_CONFIG_DESCRIPTOR_SIZE !=
1725 cur_desc->bLength) {
1726 MASS_MSG("Wrong configuration"
1727 " descriptor length");
1728 return EXIT_FAILURE;
1729 }
1730 break;
1731 }
1732
1733 case UDESC_STRING:
1734 break;
1735
1736 case UDESC_INTERFACE: {
1737 ifc_desc =
1738 (usb_interface_descriptor_t *)cur_desc;
1739
1740 if (USB_INTERFACE_DESCRIPTOR_SIZE !=
1741 cur_desc->bLength) {
1742 MASS_MSG("Wrong interface"
1743 " descriptor length");
1744 return EXIT_FAILURE;
1745 }
1746
1747 /* Check if following data is meant
1748 * for our interfaces */
1749 if ((1 << ifc_desc->bInterfaceNumber) &
1750 driver_state.cur_periph->interfaces)
1751 valid_interface = 1;
1752 else
1753 valid_interface = 0;
1754
1755 break;
1756 }
1757
1758 case UDESC_ENDPOINT: {
1759 if (USB_ENDPOINT_DESCRIPTOR_SIZE !=
1760 cur_desc->bLength) {
1761 MASS_MSG("Wrong endpoint"
1762 " descriptor length");
1763 return EXIT_FAILURE;
1764 }
1765
1766 /* Previous interface was,
1767 * what we were looking for */
1768 if (valid_interface) {
1769 if (EXIT_SUCCESS !=
1770 mass_storage_parse_endpoint(
1771 cur_desc, ep_in, ep_out))
1772 return EXIT_FAILURE;
1773
1774 }
1775
1776 break;
1777 }
1778
1779 default: {
1780 MASS_MSG("Wrong descriptor type");
1781 return EXIT_FAILURE;
1782 }
1783 }
1784
1785 } else {
1786 MASS_MSG("Invalid descriptor length");
1787 return EXIT_FAILURE;
1788 }
1789
1790 /* Get next descriptor */
1791 cur_byte += cur_desc->bLength;
1792 }
1793
1794 /* Total length should match sum of all descriptors' lengths... */
1795 if (cur_byte > buf_len)
1796 return EXIT_FAILURE;
1797
1798 /* ...and descriptors should be valid */
1799 if ((URB_INVALID_EP == ep_in->ep_num) ||
1800 (URB_INVALID_EP == ep_out->ep_num)) {
1801 MASS_MSG("Valid bulk endpoints not found");
1802 return EXIT_FAILURE;
1803 }
1804
1805 return EXIT_SUCCESS;
1806 }
MINIX 3 (repo.or.cz mirror)