275 return -EINTR; |
275 return -EINTR; |
276 |
276 |
277 if (!(slave = ec_master_find_slave_const( |
277 if (!(slave = ec_master_find_slave_const( |
278 master, 0, data.position))) { |
278 master, 0, data.position))) { |
279 up(&master->master_sem); |
279 up(&master->master_sem); |
280 EC_ERR("Slave %u does not exist!\n", data.position); |
280 EC_MASTER_ERR(master, "Slave %u does not exist!\n", data.position); |
281 return -EINVAL; |
281 return -EINVAL; |
282 } |
282 } |
283 |
283 |
284 data.vendor_id = slave->sii.vendor_id; |
284 data.vendor_id = slave->sii.vendor_id; |
285 data.product_code = slave->sii.product_code; |
285 data.product_code = slave->sii.product_code; |
359 return -EINTR; |
359 return -EINTR; |
360 |
360 |
361 if (!(slave = ec_master_find_slave_const( |
361 if (!(slave = ec_master_find_slave_const( |
362 master, 0, data.slave_position))) { |
362 master, 0, data.slave_position))) { |
363 up(&master->master_sem); |
363 up(&master->master_sem); |
364 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
364 EC_MASTER_ERR(master, "Slave %u does not exist!\n", |
|
365 data.slave_position); |
365 return -EINVAL; |
366 return -EINVAL; |
366 } |
367 } |
367 |
368 |
368 if (data.sync_index >= slave->sii.sync_count) { |
369 if (data.sync_index >= slave->sii.sync_count) { |
369 up(&master->master_sem); |
370 up(&master->master_sem); |
370 EC_ERR("Sync manager %u does not exist in slave %u!\n", |
371 EC_SLAVE_ERR(slave, "Sync manager %u does not exist!\n", |
371 data.sync_index, data.slave_position); |
372 data.sync_index); |
372 return -EINVAL; |
373 return -EINVAL; |
373 } |
374 } |
374 |
375 |
375 sync = &slave->sii.syncs[data.sync_index]; |
376 sync = &slave->sii.syncs[data.sync_index]; |
376 |
377 |
410 return -EINTR; |
411 return -EINTR; |
411 |
412 |
412 if (!(slave = ec_master_find_slave_const( |
413 if (!(slave = ec_master_find_slave_const( |
413 master, 0, data.slave_position))) { |
414 master, 0, data.slave_position))) { |
414 up(&master->master_sem); |
415 up(&master->master_sem); |
415 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
416 EC_MASTER_ERR(master, "Slave %u does not exist!\n", |
|
417 data.slave_position); |
416 return -EINVAL; |
418 return -EINVAL; |
417 } |
419 } |
418 |
420 |
419 if (data.sync_index >= slave->sii.sync_count) { |
421 if (data.sync_index >= slave->sii.sync_count) { |
420 up(&master->master_sem); |
422 up(&master->master_sem); |
421 EC_ERR("Sync manager %u does not exist in slave %u!\n", |
423 EC_SLAVE_ERR(slave, "Sync manager %u does not exist!\n", |
422 data.sync_index, data.slave_position); |
424 data.sync_index); |
423 return -EINVAL; |
425 return -EINVAL; |
424 } |
426 } |
425 |
427 |
426 sync = &slave->sii.syncs[data.sync_index]; |
428 sync = &slave->sii.syncs[data.sync_index]; |
427 if (!(pdo = ec_pdo_list_find_pdo_by_pos_const( |
429 if (!(pdo = ec_pdo_list_find_pdo_by_pos_const( |
428 &sync->pdos, data.pdo_pos))) { |
430 &sync->pdos, data.pdo_pos))) { |
429 up(&master->master_sem); |
431 up(&master->master_sem); |
430 EC_ERR("Sync manager %u does not contain a PDO with " |
432 EC_SLAVE_ERR(slave, "Sync manager %u does not contain a PDO with " |
431 "position %u in slave %u!\n", data.sync_index, |
433 "position %u!\n", data.sync_index, data.pdo_pos); |
432 data.pdo_pos, data.slave_position); |
|
433 return -EINVAL; |
434 return -EINVAL; |
434 } |
435 } |
435 |
436 |
436 data.index = pdo->index; |
437 data.index = pdo->index; |
437 data.entry_count = ec_pdo_entry_count(pdo); |
438 data.entry_count = ec_pdo_entry_count(pdo); |
468 return -EINTR; |
469 return -EINTR; |
469 |
470 |
470 if (!(slave = ec_master_find_slave_const( |
471 if (!(slave = ec_master_find_slave_const( |
471 master, 0, data.slave_position))) { |
472 master, 0, data.slave_position))) { |
472 up(&master->master_sem); |
473 up(&master->master_sem); |
473 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
474 EC_MASTER_ERR(master, "Slave %u does not exist!\n", |
|
475 data.slave_position); |
474 return -EINVAL; |
476 return -EINVAL; |
475 } |
477 } |
476 |
478 |
477 if (data.sync_index >= slave->sii.sync_count) { |
479 if (data.sync_index >= slave->sii.sync_count) { |
478 up(&master->master_sem); |
480 up(&master->master_sem); |
479 EC_ERR("Sync manager %u does not exist in slave %u!\n", |
481 EC_SLAVE_ERR(slave, "Sync manager %u does not exist!\n", |
480 data.sync_index, data.slave_position); |
482 data.sync_index); |
481 return -EINVAL; |
483 return -EINVAL; |
482 } |
484 } |
483 |
485 |
484 sync = &slave->sii.syncs[data.sync_index]; |
486 sync = &slave->sii.syncs[data.sync_index]; |
485 if (!(pdo = ec_pdo_list_find_pdo_by_pos_const( |
487 if (!(pdo = ec_pdo_list_find_pdo_by_pos_const( |
486 &sync->pdos, data.pdo_pos))) { |
488 &sync->pdos, data.pdo_pos))) { |
487 up(&master->master_sem); |
489 up(&master->master_sem); |
488 EC_ERR("Sync manager %u does not contain a PDO with " |
490 EC_SLAVE_ERR(slave, "Sync manager %u does not contain a PDO with " |
489 "position %u in slave %u!\n", data.sync_index, |
491 "position %u!\n", data.sync_index, data.pdo_pos); |
490 data.pdo_pos, data.slave_position); |
|
491 return -EINVAL; |
492 return -EINVAL; |
492 } |
493 } |
493 |
494 |
494 if (!(entry = ec_pdo_find_entry_by_pos_const( |
495 if (!(entry = ec_pdo_find_entry_by_pos_const( |
495 pdo, data.entry_pos))) { |
496 pdo, data.entry_pos))) { |
496 up(&master->master_sem); |
497 up(&master->master_sem); |
497 EC_ERR("PDO 0x%04X does not contain an entry with " |
498 EC_SLAVE_ERR(slave, "PDO 0x%04X does not contain an entry with " |
498 "position %u in slave %u!\n", data.pdo_pos, |
499 "position %u!\n", data.pdo_pos, data.entry_pos); |
499 data.entry_pos, data.slave_position); |
|
500 return -EINVAL; |
500 return -EINVAL; |
501 } |
501 } |
502 |
502 |
503 data.index = entry->index; |
503 data.index = entry->index; |
504 data.subindex = entry->subindex; |
504 data.subindex = entry->subindex; |
532 if (down_interruptible(&master->master_sem)) |
532 if (down_interruptible(&master->master_sem)) |
533 return -EINTR; |
533 return -EINTR; |
534 |
534 |
535 if (!(domain = ec_master_find_domain_const(master, data.index))) { |
535 if (!(domain = ec_master_find_domain_const(master, data.index))) { |
536 up(&master->master_sem); |
536 up(&master->master_sem); |
537 EC_ERR("Domain %u does not exist!\n", data.index); |
537 EC_MASTER_ERR(master, "Domain %u does not exist!\n", data.index); |
538 return -EINVAL; |
538 return -EINVAL; |
539 } |
539 } |
540 |
540 |
541 data.data_size = domain->data_size; |
541 data.data_size = domain->data_size; |
542 data.logical_base_address = domain->logical_base_address; |
542 data.logical_base_address = domain->logical_base_address; |
572 if (down_interruptible(&master->master_sem)) |
572 if (down_interruptible(&master->master_sem)) |
573 return -EINTR; |
573 return -EINTR; |
574 |
574 |
575 if (!(domain = ec_master_find_domain_const(master, data.domain_index))) { |
575 if (!(domain = ec_master_find_domain_const(master, data.domain_index))) { |
576 up(&master->master_sem); |
576 up(&master->master_sem); |
577 EC_ERR("Domain %u does not exist!\n", data.domain_index); |
577 EC_MASTER_ERR(master, "Domain %u does not exist!\n", |
|
578 data.domain_index); |
578 return -EINVAL; |
579 return -EINVAL; |
579 } |
580 } |
580 |
581 |
581 if (!(fmmu = ec_domain_find_fmmu(domain, data.fmmu_index))) { |
582 if (!(fmmu = ec_domain_find_fmmu(domain, data.fmmu_index))) { |
582 up(&master->master_sem); |
583 up(&master->master_sem); |
583 EC_ERR("Domain %u has less than %u fmmu configurations.\n", |
584 EC_MASTER_ERR(master, "Domain %u has less than %u" |
|
585 " fmmu configurations.\n", |
584 data.domain_index, data.fmmu_index + 1); |
586 data.domain_index, data.fmmu_index + 1); |
585 return -EINVAL; |
587 return -EINVAL; |
586 } |
588 } |
587 |
589 |
588 data.slave_config_alias = fmmu->sc->alias; |
590 data.slave_config_alias = fmmu->sc->alias; |
619 if (down_interruptible(&master->master_sem)) |
621 if (down_interruptible(&master->master_sem)) |
620 return -EINTR; |
622 return -EINTR; |
621 |
623 |
622 if (!(domain = ec_master_find_domain_const(master, data.domain_index))) { |
624 if (!(domain = ec_master_find_domain_const(master, data.domain_index))) { |
623 up(&master->master_sem); |
625 up(&master->master_sem); |
624 EC_ERR("Domain %u does not exist!\n", data.domain_index); |
626 EC_MASTER_ERR(master, "Domain %u does not exist!\n", |
|
627 data.domain_index); |
625 return -EINVAL; |
628 return -EINVAL; |
626 } |
629 } |
627 |
630 |
628 if (domain->data_size != data.data_size) { |
631 if (domain->data_size != data.data_size) { |
629 up(&master->master_sem); |
632 up(&master->master_sem); |
630 EC_ERR("Data size mismatch %u/%zu!\n", |
633 EC_MASTER_ERR(master, "Data size mismatch %u/%zu!\n", |
631 data.data_size, domain->data_size); |
634 data.data_size, domain->data_size); |
632 return -EFAULT; |
635 return -EFAULT; |
633 } |
636 } |
634 |
637 |
635 if (copy_to_user((void __user *) data.target, domain->data, |
638 if (copy_to_user((void __user *) data.target, domain->data, |
674 return -EINTR; |
677 return -EINTR; |
675 |
678 |
676 if (!(slave = ec_master_find_slave( |
679 if (!(slave = ec_master_find_slave( |
677 master, 0, data.slave_position))) { |
680 master, 0, data.slave_position))) { |
678 up(&master->master_sem); |
681 up(&master->master_sem); |
679 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
682 EC_MASTER_ERR(master, "Slave %u does not exist!\n", |
|
683 data.slave_position); |
680 return -EINVAL; |
684 return -EINVAL; |
681 } |
685 } |
682 |
686 |
683 ec_slave_request_state(slave, data.al_state); |
687 ec_slave_request_state(slave, data.al_state); |
684 |
688 |
707 return -EINTR; |
711 return -EINTR; |
708 |
712 |
709 if (!(slave = ec_master_find_slave_const( |
713 if (!(slave = ec_master_find_slave_const( |
710 master, 0, data.slave_position))) { |
714 master, 0, data.slave_position))) { |
711 up(&master->master_sem); |
715 up(&master->master_sem); |
712 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
716 EC_MASTER_ERR(master, "Slave %u does not exist!\n", |
|
717 data.slave_position); |
713 return -EINVAL; |
718 return -EINVAL; |
714 } |
719 } |
715 |
720 |
716 if (!(sdo = ec_slave_get_sdo_by_pos_const( |
721 if (!(sdo = ec_slave_get_sdo_by_pos_const( |
717 slave, data.sdo_position))) { |
722 slave, data.sdo_position))) { |
718 up(&master->master_sem); |
723 up(&master->master_sem); |
719 EC_ERR("SDO %u does not exist in slave %u!\n", |
724 EC_SLAVE_ERR(slave, "SDO %u does not exist!\n", data.sdo_position); |
720 data.sdo_position, data.slave_position); |
|
721 return -EINVAL; |
725 return -EINVAL; |
722 } |
726 } |
723 |
727 |
724 data.sdo_index = sdo->index; |
728 data.sdo_index = sdo->index; |
725 data.max_subindex = sdo->max_subindex; |
729 data.max_subindex = sdo->max_subindex; |
755 return -EINTR; |
759 return -EINTR; |
756 |
760 |
757 if (!(slave = ec_master_find_slave_const( |
761 if (!(slave = ec_master_find_slave_const( |
758 master, 0, data.slave_position))) { |
762 master, 0, data.slave_position))) { |
759 up(&master->master_sem); |
763 up(&master->master_sem); |
760 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
764 EC_MASTER_ERR(master, "Slave %u does not exist!\n", |
|
765 data.slave_position); |
761 return -EINVAL; |
766 return -EINVAL; |
762 } |
767 } |
763 |
768 |
764 if (data.sdo_spec <= 0) { |
769 if (data.sdo_spec <= 0) { |
765 if (!(sdo = ec_slave_get_sdo_by_pos_const( |
770 if (!(sdo = ec_slave_get_sdo_by_pos_const( |
766 slave, -data.sdo_spec))) { |
771 slave, -data.sdo_spec))) { |
767 up(&master->master_sem); |
772 up(&master->master_sem); |
768 EC_ERR("SDO %u does not exist in slave %u!\n", |
773 EC_SLAVE_ERR(slave, "SDO %u does not exist!\n", -data.sdo_spec); |
769 -data.sdo_spec, data.slave_position); |
|
770 return -EINVAL; |
774 return -EINVAL; |
771 } |
775 } |
772 } else { |
776 } else { |
773 if (!(sdo = ec_slave_get_sdo_const( |
777 if (!(sdo = ec_slave_get_sdo_const( |
774 slave, data.sdo_spec))) { |
778 slave, data.sdo_spec))) { |
775 up(&master->master_sem); |
779 up(&master->master_sem); |
776 EC_ERR("SDO 0x%04X does not exist in slave %u!\n", |
780 EC_SLAVE_ERR(slave, "SDO 0x%04X does not exist!\n", |
777 data.sdo_spec, data.slave_position); |
781 data.sdo_spec); |
778 return -EINVAL; |
782 return -EINVAL; |
779 } |
783 } |
780 } |
784 } |
781 |
785 |
782 if (!(entry = ec_sdo_get_entry_const( |
786 if (!(entry = ec_sdo_get_entry_const( |
783 sdo, data.sdo_entry_subindex))) { |
787 sdo, data.sdo_entry_subindex))) { |
784 up(&master->master_sem); |
788 up(&master->master_sem); |
785 EC_ERR("SDO entry 0x%04X:%02X does not exist " |
789 EC_SLAVE_ERR(slave, "SDO entry 0x%04X:%02X does not exist!\n", |
786 "in slave %u!\n", sdo->index, |
790 sdo->index, data.sdo_entry_subindex); |
787 data.sdo_entry_subindex, data.slave_position); |
|
788 return -EINVAL; |
791 return -EINVAL; |
789 } |
792 } |
790 |
793 |
791 data.data_type = entry->data_type; |
794 data.data_type = entry->data_type; |
792 data.bit_length = entry->bit_length; |
795 data.bit_length = entry->bit_length; |
839 |
842 |
840 if (!(request.slave = ec_master_find_slave( |
843 if (!(request.slave = ec_master_find_slave( |
841 master, 0, data.slave_position))) { |
844 master, 0, data.slave_position))) { |
842 up(&master->master_sem); |
845 up(&master->master_sem); |
843 ec_sdo_request_clear(&request.req); |
846 ec_sdo_request_clear(&request.req); |
844 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
847 EC_MASTER_ERR(master, "Slave %u does not exist!\n", |
845 return -EINVAL; |
848 data.slave_position); |
846 } |
849 return -EINVAL; |
847 |
850 } |
848 if (master->debug_level) |
851 |
849 EC_DBG("Schedule SDO upload request for slave %u\n", |
852 EC_SLAVE_DBG(request.slave, 1, "Schedule SDO upload request.\n"); |
850 request.slave->ring_position); |
853 |
851 // schedule request. |
854 // schedule request. |
852 list_add_tail(&request.list, &request.slave->slave_sdo_requests); |
855 list_add_tail(&request.list, &request.slave->slave_sdo_requests); |
853 |
856 |
854 up(&master->master_sem); |
857 up(&master->master_sem); |
855 |
858 |
870 |
873 |
871 // wait until master FSM has finished processing |
874 // wait until master FSM has finished processing |
872 wait_event(request.slave->sdo_queue, |
875 wait_event(request.slave->sdo_queue, |
873 request.req.state != EC_INT_REQUEST_BUSY); |
876 request.req.state != EC_INT_REQUEST_BUSY); |
874 |
877 |
875 if (master->debug_level) |
878 EC_SLAVE_DBG(request.slave, 1, "Finished SDO upload request.\n"); |
876 EC_DBG("Scheduled SDO upload request for slave %u done\n", |
|
877 request.slave->ring_position); |
|
878 |
879 |
879 data.abort_code = request.req.abort_code; |
880 data.abort_code = request.req.abort_code; |
880 |
881 |
881 if (request.req.state != EC_INT_REQUEST_SUCCESS) { |
882 if (request.req.state != EC_INT_REQUEST_SUCCESS) { |
882 data.data_size = 0; |
883 data.data_size = 0; |
883 retval = -EIO; |
884 retval = -EIO; |
884 } else { |
885 } else { |
885 if (request.req.data_size > data.target_size) { |
886 if (request.req.data_size > data.target_size) { |
886 EC_ERR("Buffer too small.\n"); |
887 EC_MASTER_ERR(master, "Buffer too small.\n"); |
887 ec_sdo_request_clear(&request.req); |
888 ec_sdo_request_clear(&request.req); |
888 return -EOVERFLOW; |
889 return -EOVERFLOW; |
889 } |
890 } |
890 data.data_size = request.req.data_size; |
891 data.data_size = request.req.data_size; |
891 |
892 |
947 return -EINTR; |
948 return -EINTR; |
948 |
949 |
949 if (!(request.slave = ec_master_find_slave( |
950 if (!(request.slave = ec_master_find_slave( |
950 master, 0, data.slave_position))) { |
951 master, 0, data.slave_position))) { |
951 up(&master->master_sem); |
952 up(&master->master_sem); |
952 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
953 EC_MASTER_ERR(master, "Slave %u does not exist!\n", |
|
954 data.slave_position); |
953 ec_sdo_request_clear(&request.req); |
955 ec_sdo_request_clear(&request.req); |
954 return -EINVAL; |
956 return -EINVAL; |
955 } |
957 } |
956 |
958 |
957 if (master->debug_level) |
959 EC_SLAVE_DBG(request.slave, 1, "Schedule SDO download request.\n"); |
958 EC_DBG("Schedule SDO download request for slave %u\n", |
960 |
959 request.slave->ring_position); |
|
960 // schedule request. |
961 // schedule request. |
961 list_add_tail(&request.list, &request.slave->slave_sdo_requests); |
962 list_add_tail(&request.list, &request.slave->slave_sdo_requests); |
962 |
963 |
963 up(&master->master_sem); |
964 up(&master->master_sem); |
964 |
965 |
979 |
980 |
980 // wait until master FSM has finished processing |
981 // wait until master FSM has finished processing |
981 wait_event(request.slave->sdo_queue, |
982 wait_event(request.slave->sdo_queue, |
982 request.req.state != EC_INT_REQUEST_BUSY); |
983 request.req.state != EC_INT_REQUEST_BUSY); |
983 |
984 |
984 if (master->debug_level) |
985 EC_SLAVE_DBG(request.slave, 1, "Finished SDO download request.\n"); |
985 EC_DBG("Scheduled SDO download request for slave %u done\n", |
|
986 request.slave->ring_position); |
|
987 |
986 |
988 data.abort_code = request.req.abort_code; |
987 data.abort_code = request.req.abort_code; |
989 |
988 |
990 retval = request.req.state == EC_INT_REQUEST_SUCCESS ? 0 : -EIO; |
989 retval = request.req.state == EC_INT_REQUEST_SUCCESS ? 0 : -EIO; |
991 |
990 |
1018 return -EINTR; |
1017 return -EINTR; |
1019 |
1018 |
1020 if (!(slave = ec_master_find_slave_const( |
1019 if (!(slave = ec_master_find_slave_const( |
1021 master, 0, data.slave_position))) { |
1020 master, 0, data.slave_position))) { |
1022 up(&master->master_sem); |
1021 up(&master->master_sem); |
1023 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
1022 EC_MASTER_ERR(master, "Slave %u does not exist!\n", |
|
1023 data.slave_position); |
1024 return -EINVAL; |
1024 return -EINVAL; |
1025 } |
1025 } |
1026 |
1026 |
1027 if (!data.nwords |
1027 if (!data.nwords |
1028 || data.offset + data.nwords > slave->sii_nwords) { |
1028 || data.offset + data.nwords > slave->sii_nwords) { |
1029 up(&master->master_sem); |
1029 up(&master->master_sem); |
1030 EC_ERR("Invalid SII read offset/size %u/%u for slave " |
1030 EC_SLAVE_ERR(slave, "Invalid SII read offset/size %u/%u for slave SII" |
1031 "SII size %zu!\n", data.offset, |
1031 " size %zu!\n", data.offset, data.nwords, slave->sii_nwords); |
1032 data.nwords, slave->sii_nwords); |
|
1033 return -EINVAL; |
1032 return -EINVAL; |
1034 } |
1033 } |
1035 |
1034 |
1036 if (copy_to_user((void __user *) data.words, |
1035 if (copy_to_user((void __user *) data.words, |
1037 slave->sii_words + data.offset, data.nwords * 2)) |
1036 slave->sii_words + data.offset, data.nwords * 2)) |
1065 if (!data.nwords) |
1064 if (!data.nwords) |
1066 return 0; |
1065 return 0; |
1067 |
1066 |
1068 byte_size = sizeof(uint16_t) * data.nwords; |
1067 byte_size = sizeof(uint16_t) * data.nwords; |
1069 if (!(words = kmalloc(byte_size, GFP_KERNEL))) { |
1068 if (!(words = kmalloc(byte_size, GFP_KERNEL))) { |
1070 EC_ERR("Failed to allocate %u bytes for SII contents.\n", |
1069 EC_MASTER_ERR(master, "Failed to allocate %u bytes" |
1071 byte_size); |
1070 " for SII contents.\n", byte_size); |
1072 return -ENOMEM; |
1071 return -ENOMEM; |
1073 } |
1072 } |
1074 |
1073 |
1075 if (copy_from_user(words, |
1074 if (copy_from_user(words, |
1076 (void __user *) data.words, byte_size)) { |
1075 (void __user *) data.words, byte_size)) { |
1082 return -EINTR; |
1081 return -EINTR; |
1083 |
1082 |
1084 if (!(slave = ec_master_find_slave( |
1083 if (!(slave = ec_master_find_slave( |
1085 master, 0, data.slave_position))) { |
1084 master, 0, data.slave_position))) { |
1086 up(&master->master_sem); |
1085 up(&master->master_sem); |
1087 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
1086 EC_MASTER_ERR(master, "Slave %u does not exist!\n", |
|
1087 data.slave_position); |
1088 kfree(words); |
1088 kfree(words); |
1089 return -EINVAL; |
1089 return -EINVAL; |
1090 } |
1090 } |
1091 |
1091 |
1092 // init SII write request |
1092 // init SII write request |
1145 |
1145 |
1146 if (!data.length) |
1146 if (!data.length) |
1147 return 0; |
1147 return 0; |
1148 |
1148 |
1149 if (!(contents = kmalloc(data.length, GFP_KERNEL))) { |
1149 if (!(contents = kmalloc(data.length, GFP_KERNEL))) { |
1150 EC_ERR("Failed to allocate %u bytes for register data.\n", |
1150 EC_MASTER_ERR(master, "Failed to allocate %u bytes" |
1151 data.length); |
1151 " for register data.\n", data.length); |
1152 return -ENOMEM; |
1152 return -ENOMEM; |
1153 } |
1153 } |
1154 |
1154 |
1155 if (down_interruptible(&master->master_sem)) |
1155 if (down_interruptible(&master->master_sem)) |
1156 return -EINTR; |
1156 return -EINTR; |
1157 |
1157 |
1158 if (!(slave = ec_master_find_slave( |
1158 if (!(slave = ec_master_find_slave( |
1159 master, 0, data.slave_position))) { |
1159 master, 0, data.slave_position))) { |
1160 up(&master->master_sem); |
1160 up(&master->master_sem); |
1161 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
1161 EC_MASTER_ERR(master, "Slave %u does not exist!\n", |
|
1162 data.slave_position); |
1162 return -EINVAL; |
1163 return -EINVAL; |
1163 } |
1164 } |
1164 |
1165 |
1165 // init register request |
1166 // init register request |
1166 INIT_LIST_HEAD(&request.list); |
1167 INIT_LIST_HEAD(&request.list); |
1239 return -EINTR; |
1240 return -EINTR; |
1240 |
1241 |
1241 if (!(slave = ec_master_find_slave( |
1242 if (!(slave = ec_master_find_slave( |
1242 master, 0, data.slave_position))) { |
1243 master, 0, data.slave_position))) { |
1243 up(&master->master_sem); |
1244 up(&master->master_sem); |
1244 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
1245 EC_MASTER_ERR(master, "Slave %u does not exist!\n", |
|
1246 data.slave_position); |
1245 kfree(contents); |
1247 kfree(contents); |
1246 return -EINVAL; |
1248 return -EINVAL; |
1247 } |
1249 } |
1248 |
1250 |
1249 // init register request |
1251 // init register request |
1304 return -EINTR; |
1306 return -EINTR; |
1305 |
1307 |
1306 if (!(sc = ec_master_get_config_const( |
1308 if (!(sc = ec_master_get_config_const( |
1307 master, data.config_index))) { |
1309 master, data.config_index))) { |
1308 up(&master->master_sem); |
1310 up(&master->master_sem); |
1309 EC_ERR("Slave config %u does not exist!\n", |
1311 EC_MASTER_ERR(master, "Slave config %u does not exist!\n", |
1310 data.config_index); |
1312 data.config_index); |
1311 return -EINVAL; |
1313 return -EINVAL; |
1312 } |
1314 } |
1313 |
1315 |
1314 data.alias = sc->alias; |
1316 data.alias = sc->alias; |
1354 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
1356 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
1355 return -EFAULT; |
1357 return -EFAULT; |
1356 } |
1358 } |
1357 |
1359 |
1358 if (data.sync_index >= EC_MAX_SYNC_MANAGERS) { |
1360 if (data.sync_index >= EC_MAX_SYNC_MANAGERS) { |
1359 EC_ERR("Invalid sync manager index %u!\n", |
1361 EC_MASTER_ERR(master, "Invalid sync manager index %u!\n", |
1360 data.sync_index); |
1362 data.sync_index); |
1361 return -EINVAL; |
1363 return -EINVAL; |
1362 } |
1364 } |
1363 |
1365 |
1364 if (down_interruptible(&master->master_sem)) |
1366 if (down_interruptible(&master->master_sem)) |
1365 return -EINTR; |
1367 return -EINTR; |
1366 |
1368 |
1367 if (!(sc = ec_master_get_config_const( |
1369 if (!(sc = ec_master_get_config_const( |
1368 master, data.config_index))) { |
1370 master, data.config_index))) { |
1369 up(&master->master_sem); |
1371 up(&master->master_sem); |
1370 EC_ERR("Slave config %u does not exist!\n", |
1372 EC_MASTER_ERR(master, "Slave config %u does not exist!\n", |
1371 data.config_index); |
1373 data.config_index); |
1372 return -EINVAL; |
1374 return -EINVAL; |
1373 } |
1375 } |
1374 |
1376 |
1375 if (!(pdo = ec_pdo_list_find_pdo_by_pos_const( |
1377 if (!(pdo = ec_pdo_list_find_pdo_by_pos_const( |
1376 &sc->sync_configs[data.sync_index].pdos, |
1378 &sc->sync_configs[data.sync_index].pdos, |
1377 data.pdo_pos))) { |
1379 data.pdo_pos))) { |
1378 up(&master->master_sem); |
1380 up(&master->master_sem); |
1379 EC_ERR("Invalid PDO position!\n"); |
1381 EC_MASTER_ERR(master, "Invalid PDO position!\n"); |
1380 return -EINVAL; |
1382 return -EINVAL; |
1381 } |
1383 } |
1382 |
1384 |
1383 data.index = pdo->index; |
1385 data.index = pdo->index; |
1384 data.entry_count = ec_pdo_entry_count(pdo); |
1386 data.entry_count = ec_pdo_entry_count(pdo); |
1409 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
1411 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
1410 return -EFAULT; |
1412 return -EFAULT; |
1411 } |
1413 } |
1412 |
1414 |
1413 if (data.sync_index >= EC_MAX_SYNC_MANAGERS) { |
1415 if (data.sync_index >= EC_MAX_SYNC_MANAGERS) { |
1414 EC_ERR("Invalid sync manager index %u!\n", |
1416 EC_MASTER_ERR(master, "Invalid sync manager index %u!\n", |
1415 data.sync_index); |
1417 data.sync_index); |
1416 return -EINVAL; |
1418 return -EINVAL; |
1417 } |
1419 } |
1418 |
1420 |
1419 if (down_interruptible(&master->master_sem)) |
1421 if (down_interruptible(&master->master_sem)) |
1420 return -EINTR; |
1422 return -EINTR; |
1421 |
1423 |
1422 if (!(sc = ec_master_get_config_const( |
1424 if (!(sc = ec_master_get_config_const( |
1423 master, data.config_index))) { |
1425 master, data.config_index))) { |
1424 up(&master->master_sem); |
1426 up(&master->master_sem); |
1425 EC_ERR("Slave config %u does not exist!\n", |
1427 EC_MASTER_ERR(master, "Slave config %u does not exist!\n", |
1426 data.config_index); |
1428 data.config_index); |
1427 return -EINVAL; |
1429 return -EINVAL; |
1428 } |
1430 } |
1429 |
1431 |
1430 if (!(pdo = ec_pdo_list_find_pdo_by_pos_const( |
1432 if (!(pdo = ec_pdo_list_find_pdo_by_pos_const( |
1431 &sc->sync_configs[data.sync_index].pdos, |
1433 &sc->sync_configs[data.sync_index].pdos, |
1432 data.pdo_pos))) { |
1434 data.pdo_pos))) { |
1433 up(&master->master_sem); |
1435 up(&master->master_sem); |
1434 EC_ERR("Invalid PDO position!\n"); |
1436 EC_MASTER_ERR(master, "Invalid PDO position!\n"); |
1435 return -EINVAL; |
1437 return -EINVAL; |
1436 } |
1438 } |
1437 |
1439 |
1438 if (!(entry = ec_pdo_find_entry_by_pos_const( |
1440 if (!(entry = ec_pdo_find_entry_by_pos_const( |
1439 pdo, data.entry_pos))) { |
1441 pdo, data.entry_pos))) { |
1440 up(&master->master_sem); |
1442 up(&master->master_sem); |
1441 EC_ERR("Entry not found!\n"); |
1443 EC_MASTER_ERR(master, "Entry not found!\n"); |
1442 return -EINVAL; |
1444 return -EINVAL; |
1443 } |
1445 } |
1444 |
1446 |
1445 data.index = entry->index; |
1447 data.index = entry->index; |
1446 data.subindex = entry->subindex; |
1448 data.subindex = entry->subindex; |
1476 return -EINTR; |
1478 return -EINTR; |
1477 |
1479 |
1478 if (!(sc = ec_master_get_config_const( |
1480 if (!(sc = ec_master_get_config_const( |
1479 master, data.config_index))) { |
1481 master, data.config_index))) { |
1480 up(&master->master_sem); |
1482 up(&master->master_sem); |
1481 EC_ERR("Slave config %u does not exist!\n", |
1483 EC_MASTER_ERR(master, "Slave config %u does not exist!\n", |
1482 data.config_index); |
1484 data.config_index); |
1483 return -EINVAL; |
1485 return -EINVAL; |
1484 } |
1486 } |
1485 |
1487 |
1486 if (!(req = ec_slave_config_get_sdo_by_pos_const( |
1488 if (!(req = ec_slave_config_get_sdo_by_pos_const( |
1487 sc, data.sdo_pos))) { |
1489 sc, data.sdo_pos))) { |
1488 up(&master->master_sem); |
1490 up(&master->master_sem); |
1489 EC_ERR("Invalid SDO position!\n"); |
1491 EC_MASTER_ERR(master, "Invalid SDO position!\n"); |
1490 return -EINVAL; |
1492 return -EINVAL; |
1491 } |
1493 } |
1492 |
1494 |
1493 data.index = req->index; |
1495 data.index = req->index; |
1494 data.subindex = req->subindex; |
1496 data.subindex = req->subindex; |
1525 if (down_interruptible(&master->master_sem)) |
1527 if (down_interruptible(&master->master_sem)) |
1526 return -EINTR; |
1528 return -EINTR; |
1527 |
1529 |
1528 if (!(eoe = ec_master_get_eoe_handler_const(master, data.eoe_index))) { |
1530 if (!(eoe = ec_master_get_eoe_handler_const(master, data.eoe_index))) { |
1529 up(&master->master_sem); |
1531 up(&master->master_sem); |
1530 EC_ERR("EoE handler %u does not exist!\n", data.eoe_index); |
1532 EC_MASTER_ERR(master, "EoE handler %u does not exist!\n", |
|
1533 data.eoe_index); |
1531 return -EINVAL; |
1534 return -EINVAL; |
1532 } |
1535 } |
1533 |
1536 |
1534 if (eoe->slave) { |
1537 if (eoe->slave) { |
1535 data.slave_position = eoe->slave->ring_position; |
1538 data.slave_position = eoe->slave->ring_position; |
3151 |
3154 |
3152 if (!(request.slave = ec_master_find_slave( |
3155 if (!(request.slave = ec_master_find_slave( |
3153 master, 0, data.slave_position))) { |
3156 master, 0, data.slave_position))) { |
3154 up(&master->master_sem); |
3157 up(&master->master_sem); |
3155 ec_foe_request_clear(&request.req); |
3158 ec_foe_request_clear(&request.req); |
3156 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
3159 EC_MASTER_ERR(master, "Slave %u does not exist!\n", |
|
3160 data.slave_position); |
3157 return -EINVAL; |
3161 return -EINVAL; |
3158 } |
3162 } |
3159 |
3163 |
3160 // schedule request. |
3164 // schedule request. |
3161 list_add_tail(&request.list, &request.slave->foe_requests); |
3165 list_add_tail(&request.list, &request.slave->foe_requests); |
3162 |
3166 |
3163 up(&master->master_sem); |
3167 up(&master->master_sem); |
3164 |
3168 |
3165 if (master->debug_level) { |
3169 EC_SLAVE_DBG(request.slave, 1, "Scheduled FoE read request.\n"); |
3166 EC_DBG("Scheduled FoE read request on slave %u.\n", |
|
3167 request.slave->ring_position); |
|
3168 } |
|
3169 |
3170 |
3170 // wait for processing through FSM |
3171 // wait for processing through FSM |
3171 if (wait_event_interruptible(request.slave->foe_queue, |
3172 if (wait_event_interruptible(request.slave->foe_queue, |
3172 request.req.state != EC_INT_REQUEST_QUEUED)) { |
3173 request.req.state != EC_INT_REQUEST_QUEUED)) { |
3173 // interrupted by signal |
3174 // interrupted by signal |
3187 request.req.state != EC_INT_REQUEST_BUSY); |
3188 request.req.state != EC_INT_REQUEST_BUSY); |
3188 |
3189 |
3189 data.result = request.req.result; |
3190 data.result = request.req.result; |
3190 data.error_code = request.req.error_code; |
3191 data.error_code = request.req.error_code; |
3191 |
3192 |
3192 if (master->debug_level) { |
3193 EC_SLAVE_DBG(request.slave, 1, "Read %zd bytes via FoE" |
3193 EC_DBG("Read %zd bytes via FoE (result = 0x%x).\n", |
3194 " (result = 0x%x).\n", request.req.data_size, request.req.result); |
3194 request.req.data_size, request.req.result); |
|
3195 } |
|
3196 |
3195 |
3197 if (request.req.state != EC_INT_REQUEST_SUCCESS) { |
3196 if (request.req.state != EC_INT_REQUEST_SUCCESS) { |
3198 data.data_size = 0; |
3197 data.data_size = 0; |
3199 retval = -EIO; |
3198 retval = -EIO; |
3200 } else { |
3199 } else { |
3201 if (request.req.data_size > data.buffer_size) { |
3200 if (request.req.data_size > data.buffer_size) { |
3202 EC_ERR("Buffer too small.\n"); |
3201 EC_MASTER_ERR(master, "Buffer too small.\n"); |
3203 ec_foe_request_clear(&request.req); |
3202 ec_foe_request_clear(&request.req); |
3204 return -EOVERFLOW; |
3203 return -EOVERFLOW; |
3205 } |
3204 } |
3206 data.data_size = request.req.data_size; |
3205 data.data_size = request.req.data_size; |
3207 if (copy_to_user((void __user *) data.buffer, |
3206 if (copy_to_user((void __user *) data.buffer, |
3262 return -EINTR; |
3259 return -EINTR; |
3263 |
3260 |
3264 if (!(request.slave = ec_master_find_slave( |
3261 if (!(request.slave = ec_master_find_slave( |
3265 master, 0, data.slave_position))) { |
3262 master, 0, data.slave_position))) { |
3266 up(&master->master_sem); |
3263 up(&master->master_sem); |
3267 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
3264 EC_MASTER_ERR(master, "Slave %u does not exist!\n", |
|
3265 data.slave_position); |
3268 ec_foe_request_clear(&request.req); |
3266 ec_foe_request_clear(&request.req); |
3269 return -EINVAL; |
3267 return -EINVAL; |
3270 } |
3268 } |
3271 |
3269 |
3272 if (master->debug_level) { |
3270 EC_SLAVE_DBG(request.slave, 1, "Scheduling FoE write request.\n"); |
3273 EC_DBG("Scheduling FoE write request.\n"); |
|
3274 } |
|
3275 |
3271 |
3276 // schedule FoE write request. |
3272 // schedule FoE write request. |
3277 list_add_tail(&request.list, &request.slave->foe_requests); |
3273 list_add_tail(&request.list, &request.slave->foe_requests); |
3278 |
3274 |
3279 up(&master->master_sem); |
3275 up(&master->master_sem); |
3341 |
3335 |
3342 if (!(request.slave = ec_master_find_slave( |
3336 if (!(request.slave = ec_master_find_slave( |
3343 master, 0, ioctl.slave_position))) { |
3337 master, 0, ioctl.slave_position))) { |
3344 up(&master->master_sem); |
3338 up(&master->master_sem); |
3345 ec_soe_request_clear(&request.req); |
3339 ec_soe_request_clear(&request.req); |
3346 EC_ERR("Slave %u does not exist!\n", ioctl.slave_position); |
3340 EC_MASTER_ERR(master, "Slave %u does not exist!\n", |
|
3341 ioctl.slave_position); |
3347 return -EINVAL; |
3342 return -EINVAL; |
3348 } |
3343 } |
3349 |
3344 |
3350 // schedule request. |
3345 // schedule request. |
3351 list_add_tail(&request.list, &request.slave->soe_requests); |
3346 list_add_tail(&request.list, &request.slave->soe_requests); |
3352 |
3347 |
3353 up(&master->master_sem); |
3348 up(&master->master_sem); |
3354 |
3349 |
3355 if (master->debug_level) { |
3350 EC_SLAVE_DBG(request.slave, 1, "Scheduled SoE read request.\n"); |
3356 EC_DBG("Scheduled SoE read request on slave %u.\n", |
|
3357 request.slave->ring_position); |
|
3358 } |
|
3359 |
3351 |
3360 // wait for processing through FSM |
3352 // wait for processing through FSM |
3361 if (wait_event_interruptible(request.slave->soe_queue, |
3353 if (wait_event_interruptible(request.slave->soe_queue, |
3362 request.req.state != EC_INT_REQUEST_QUEUED)) { |
3354 request.req.state != EC_INT_REQUEST_QUEUED)) { |
3363 // interrupted by signal |
3355 // interrupted by signal |
3376 wait_event(request.slave->soe_queue, |
3368 wait_event(request.slave->soe_queue, |
3377 request.req.state != EC_INT_REQUEST_BUSY); |
3369 request.req.state != EC_INT_REQUEST_BUSY); |
3378 |
3370 |
3379 ioctl.error_code = request.req.error_code; |
3371 ioctl.error_code = request.req.error_code; |
3380 |
3372 |
3381 if (master->debug_level) { |
3373 EC_SLAVE_DBG(request.slave, 1, "Read %zd bytes via SoE.\n", |
3382 EC_DBG("Read %zd bytes via SoE.\n", request.req.data_size); |
3374 request.req.data_size); |
3383 } |
|
3384 |
3375 |
3385 if (request.req.state != EC_INT_REQUEST_SUCCESS) { |
3376 if (request.req.state != EC_INT_REQUEST_SUCCESS) { |
3386 ioctl.data_size = 0; |
3377 ioctl.data_size = 0; |
3387 retval = -EIO; |
3378 retval = -EIO; |
3388 } else { |
3379 } else { |
3389 if (request.req.data_size > ioctl.mem_size) { |
3380 if (request.req.data_size > ioctl.mem_size) { |
3390 EC_ERR("Buffer too small.\n"); |
3381 EC_MASTER_ERR(master, "Buffer too small.\n"); |
3391 ec_soe_request_clear(&request.req); |
3382 ec_soe_request_clear(&request.req); |
3392 return -EOVERFLOW; |
3383 return -EOVERFLOW; |
3393 } |
3384 } |
3394 ioctl.data_size = request.req.data_size; |
3385 ioctl.data_size = request.req.data_size; |
3395 if (copy_to_user((void __user *) ioctl.data, |
3386 if (copy_to_user((void __user *) ioctl.data, |
3451 return -EINTR; |
3440 return -EINTR; |
3452 |
3441 |
3453 if (!(request.slave = ec_master_find_slave( |
3442 if (!(request.slave = ec_master_find_slave( |
3454 master, 0, ioctl.slave_position))) { |
3443 master, 0, ioctl.slave_position))) { |
3455 up(&master->master_sem); |
3444 up(&master->master_sem); |
3456 EC_ERR("Slave %u does not exist!\n", ioctl.slave_position); |
3445 EC_MASTER_ERR(master, "Slave %u does not exist!\n", |
|
3446 ioctl.slave_position); |
3457 ec_soe_request_clear(&request.req); |
3447 ec_soe_request_clear(&request.req); |
3458 return -EINVAL; |
3448 return -EINVAL; |
3459 } |
3449 } |
3460 |
3450 |
3461 if (master->debug_level) { |
3451 EC_SLAVE_DBG(request.slave, 1, "Scheduling SoE write request.\n"); |
3462 EC_DBG("Scheduling SoE write request.\n"); |
|
3463 } |
|
3464 |
3452 |
3465 // schedule SoE write request. |
3453 // schedule SoE write request. |
3466 list_add_tail(&request.list, &request.slave->soe_requests); |
3454 list_add_tail(&request.list, &request.slave->soe_requests); |
3467 |
3455 |
3468 up(&master->master_sem); |
3456 up(&master->master_sem); |
3563 { |
3549 { |
3564 ec_cdev_priv_t *priv = (ec_cdev_priv_t *) filp->private_data; |
3550 ec_cdev_priv_t *priv = (ec_cdev_priv_t *) filp->private_data; |
3565 ec_master_t *master = priv->cdev->master; |
3551 ec_master_t *master = priv->cdev->master; |
3566 |
3552 |
3567 #if DEBUG_IOCTL |
3553 #if DEBUG_IOCTL |
3568 EC_DBG("ioctl(filp = 0x%x, cmd = 0x%08x (0x%02x), arg = 0x%x)\n", |
3554 EC_MASTER_DBG(master, "ioctl(filp = 0x%x, cmd = 0x%08x (0x%02x)," |
3569 (u32) filp, (u32) cmd, (u32) _IOC_NR(cmd), (u32) arg); |
3555 " arg = 0x%x)\n", (u32) filp, (u32) cmd, (u32) _IOC_NR(cmd), |
|
3556 (u32) arg); |
3570 #endif |
3557 #endif |
3571 |
3558 |
3572 switch (cmd) { |
3559 switch (cmd) { |
3573 case EC_IOCTL_MODULE: |
3560 case EC_IOCTL_MODULE: |
3574 return ec_cdev_ioctl_module(arg); |
3561 return ec_cdev_ioctl_module(arg); |
3795 case EC_IOCTL_VOE_DATA: |
3782 case EC_IOCTL_VOE_DATA: |
3796 return ec_cdev_ioctl_voe_data(master, arg, priv); |
3783 return ec_cdev_ioctl_voe_data(master, arg, priv); |
3797 case EC_IOCTL_SET_SEND_INTERVAL: |
3784 case EC_IOCTL_SET_SEND_INTERVAL: |
3798 if (!(filp->f_mode & FMODE_WRITE)) |
3785 if (!(filp->f_mode & FMODE_WRITE)) |
3799 return -EPERM; |
3786 return -EPERM; |
3800 return ec_cdev_ioctl_set_send_interval(master,arg,priv); |
3787 return ec_cdev_ioctl_set_send_interval(master, arg, priv); |
3801 default: |
3788 default: |
3802 return -ENOTTY; |
3789 return -ENOTTY; |
3803 } |
3790 } |
3804 } |
3791 } |
3805 |
3792 |
3815 struct vm_area_struct *vma |
3802 struct vm_area_struct *vma |
3816 ) |
3803 ) |
3817 { |
3804 { |
3818 ec_cdev_priv_t *priv = (ec_cdev_priv_t *) filp->private_data; |
3805 ec_cdev_priv_t *priv = (ec_cdev_priv_t *) filp->private_data; |
3819 |
3806 |
3820 if (priv->cdev->master->debug_level) |
3807 EC_MASTER_DBG(priv->cdev->master, 1, "mmap()\n"); |
3821 EC_DBG("mmap()\n"); |
|
3822 |
3808 |
3823 vma->vm_ops = &eccdev_vm_ops; |
3809 vma->vm_ops = &eccdev_vm_ops; |
3824 vma->vm_flags |= VM_RESERVED; /* Pages will not be swapped out */ |
3810 vma->vm_flags |= VM_RESERVED; /* Pages will not be swapped out */ |
3825 vma->vm_private_data = priv; |
3811 vma->vm_private_data = priv; |
3826 |
3812 |
3853 return VM_FAULT_SIGBUS; |
3839 return VM_FAULT_SIGBUS; |
3854 |
3840 |
3855 get_page(page); |
3841 get_page(page); |
3856 vmf->page = page; |
3842 vmf->page = page; |
3857 |
3843 |
3858 if (priv->cdev->master->debug_level) |
3844 EC_MASTER_DBG(priv->cdev->master, 1, "Vma fault, virtual_address = %p," |
3859 EC_DBG("Vma fault, virtual_address = %p, offset = %lu, page = %p\n", |
3845 " offset = %lu, page = %p\n", vmf->virtual_address, offset, page); |
3860 vmf->virtual_address, offset, page); |
|
3861 |
3846 |
3862 return 0; |
3847 return 0; |
3863 } |
3848 } |
3864 |
3849 |
3865 #else |
3850 #else |
3885 if (offset >= priv->process_data_size) |
3870 if (offset >= priv->process_data_size) |
3886 return NOPAGE_SIGBUS; |
3871 return NOPAGE_SIGBUS; |
3887 |
3872 |
3888 page = vmalloc_to_page(priv->process_data + offset); |
3873 page = vmalloc_to_page(priv->process_data + offset); |
3889 |
3874 |
3890 if (priv->cdev->master->debug_level) |
3875 EC_MASTER_DBG(master, "Nopage fault vma, address = %#lx," |
3891 EC_DBG("Nopage fault vma, address = %#lx, offset = %#lx, page = %p\n", |
3876 " offset = %#lx, page = %p\n", address, offset, page); |
3892 address, offset, page); |
|
3893 |
3877 |
3894 get_page(page); |
3878 get_page(page); |
3895 if (type) |
3879 if (type) |
3896 *type = VM_FAULT_MINOR; |
3880 *type = VM_FAULT_MINOR; |
3897 |
3881 |