Merge tag 'for-linus-7.1-1' of https://github.com/cminyard/linux-ipmi

+10

drivers/char/ipmi/Kconfig

··· 187 187 The driver implements the BMC side of the SMBus system 188 188 interface (SSIF). 189 189 190 + config SSIF_IPMI_BMC_KUNIT_TEST 191 + bool "KUnit tests for SSIF IPMI BMC driver" if !KUNIT_ALL_TESTS 192 + depends on KUNIT=y 193 + depends on SSIF_IPMI_BMC 194 + default KUNIT_ALL_TESTS 195 + help 196 + This option builds unit tests that exercise the SSIF BMC state 197 + machine, including request handling, response transmission, 198 + and error paths such as aborted or truncated transfers. 199 + 190 200 config IPMB_DEVICE_INTERFACE 191 201 tristate 'IPMB Interface handler' 192 202 depends on I2C

+5 -5

drivers/char/ipmi/ipmi_msghandler.c

··· 987 987 mutex_lock(&intf->user_msgs_mutex); 988 988 list_add_tail(&msg->link, &intf->user_msgs); 989 989 mutex_unlock(&intf->user_msgs_mutex); 990 - queue_work(system_wq, &intf->smi_work); 990 + queue_work(system_percpu_wq, &intf->smi_work); 991 991 } 992 992 993 993 return rv; ··· 4977 4977 if (run_to_completion) 4978 4978 smi_work(&intf->smi_work); 4979 4979 else 4980 - queue_work(system_wq, &intf->smi_work); 4980 + queue_work(system_percpu_wq, &intf->smi_work); 4981 4981 } 4982 4982 EXPORT_SYMBOL(ipmi_smi_msg_received); 4983 4983 ··· 4987 4987 return; 4988 4988 4989 4989 atomic_set(&intf->watchdog_pretimeouts_to_deliver, 1); 4990 - queue_work(system_wq, &intf->smi_work); 4990 + queue_work(system_percpu_wq, &intf->smi_work); 4991 4991 } 4992 4992 EXPORT_SYMBOL(ipmi_smi_watchdog_pretimeout); 4993 4993 ··· 5162 5162 flags); 5163 5163 } 5164 5164 5165 - queue_work(system_wq, &intf->smi_work); 5165 + queue_work(system_percpu_wq, &intf->smi_work); 5166 5166 5167 5167 return need_timer; 5168 5168 } ··· 5218 5218 if (atomic_read(&stop_operation)) 5219 5219 return; 5220 5220 5221 - queue_work(system_wq, &ipmi_timer_work); 5221 + queue_work(system_percpu_wq, &ipmi_timer_work); 5222 5222 } 5223 5223 5224 5224 static void need_waiter(struct ipmi_smi *intf)

+24 -17

drivers/char/ipmi/ipmi_ssif.c

··· 1268 1268 ssif_info->stopping = true; 1269 1269 timer_delete_sync(&ssif_info->watch_timer); 1270 1270 timer_delete_sync(&ssif_info->retry_timer); 1271 - if (ssif_info->thread) 1271 + if (ssif_info->thread) { 1272 1272 kthread_stop(ssif_info->thread); 1273 + ssif_info->thread = NULL; 1274 + } 1273 1275 } 1274 1276 1275 1277 static void ssif_remove(struct i2c_client *client) ··· 1660 1658 int len = 0; 1661 1659 int i; 1662 1660 u8 slave_addr = 0; 1661 + unsigned int thread_num; 1663 1662 struct ssif_addr_info *addr_info = NULL; 1664 1663 1665 1664 mutex_lock(&ssif_infos_mutex); ··· 1879 1876 ssif_info->handlers.request_events = request_events; 1880 1877 ssif_info->handlers.set_need_watch = ssif_set_need_watch; 1881 1878 1882 - { 1883 - unsigned int thread_num; 1884 - 1885 - thread_num = ((i2c_adapter_id(ssif_info->client->adapter) 1886 - << 8) | 1887 - ssif_info->client->addr); 1888 - init_completion(&ssif_info->wake_thread); 1889 - ssif_info->thread = kthread_run(ipmi_ssif_thread, ssif_info, 1890 - "kssif%4.4x", thread_num); 1891 - if (IS_ERR(ssif_info->thread)) { 1892 - rv = PTR_ERR(ssif_info->thread); 1893 - dev_notice(&ssif_info->client->dev, 1894 - "Could not start kernel thread: error %d\n", 1895 - rv); 1896 - goto out; 1897 - } 1879 + thread_num = ((i2c_adapter_id(ssif_info->client->adapter) << 8) | 1880 + ssif_info->client->addr); 1881 + init_completion(&ssif_info->wake_thread); 1882 + ssif_info->thread = kthread_run(ipmi_ssif_thread, ssif_info, 1883 + "kssif%4.4x", thread_num); 1884 + if (IS_ERR(ssif_info->thread)) { 1885 + rv = PTR_ERR(ssif_info->thread); 1886 + dev_notice(&ssif_info->client->dev, 1887 + "Could not start kernel thread: error %d\n", 1888 + rv); 1889 + goto out; 1898 1890 } 1899 1891 1900 1892 dev_set_drvdata(&ssif_info->client->dev, ssif_info); ··· 1914 1916 1915 1917 out: 1916 1918 if (rv) { 1919 + /* 1920 + * If ipmi_register_smi() starts the interface, it will 1921 + * call shutdown and that will free the thread and set 1922 + * it to NULL. Otherwise it must be freed here. 1923 + */ 1924 + if (ssif_info->thread) { 1925 + kthread_stop(ssif_info->thread); 1926 + ssif_info->thread = NULL; 1927 + } 1917 1928 if (addr_info) 1918 1929 addr_info->client = NULL; 1919 1930

+396 -9

drivers/char/ipmi/ssif_bmc.c

··· 18 18 #include <linux/timer.h> 19 19 #include <linux/jiffies.h> 20 20 #include <linux/ipmi_ssif_bmc.h> 21 + #if IS_ENABLED(CONFIG_SSIF_IPMI_BMC_KUNIT_TEST) 22 + #include <kunit/test.h> 23 + #endif 21 24 22 25 #define DEVICE_NAME "ipmi-ssif-host" 23 26 ··· 166 163 spin_unlock_irqrestore(&ssif_bmc->lock, flags); 167 164 168 165 ret = copy_to_user(buf, &msg, count); 166 + if (ret > 0) 167 + ret = -EFAULT; 169 168 } 170 169 171 170 return (ret < 0) ? ret : count; ··· 461 456 return false; 462 457 } 463 458 459 + static bool supported_write_start_cmd(u8 cmd) 460 + { 461 + if (cmd == SSIF_IPMI_SINGLEPART_WRITE || 462 + cmd == SSIF_IPMI_MULTIPART_WRITE_START) 463 + return true; 464 + 465 + return false; 466 + } 467 + 464 468 /* Process the IPMI response that will be read by master */ 465 469 static void handle_read_processed(struct ssif_bmc_ctx *ssif_bmc, u8 *val) 466 470 { ··· 572 558 len = ssif_bmc->request.len + part->length; 573 559 /* Do the bound check here, not allow the request len exceed 254 bytes */ 574 560 if (len > IPMI_SSIF_PAYLOAD_MAX) { 575 - dev_warn(&ssif_bmc->client->dev, 561 + dev_dbg(&ssif_bmc->client->dev, 576 562 "Warn: Request exceeded 254 bytes, aborting"); 577 563 /* Request too long, aborting */ 578 564 ssif_bmc->aborting = true; ··· 618 604 ssif_bmc->state == SSIF_START || 619 605 ssif_bmc->state == SSIF_REQ_RECVING || 620 606 ssif_bmc->state == SSIF_RES_SENDING) { 621 - dev_warn(&ssif_bmc->client->dev, 607 + dev_dbg(&ssif_bmc->client->dev, 622 608 "Warn: %s unexpected READ REQUESTED in state=%s\n", 623 609 __func__, state_to_string(ssif_bmc->state)); 624 610 ssif_bmc->state = SSIF_ABORTING; ··· 627 613 628 614 } else if (ssif_bmc->state == SSIF_SMBUS_CMD) { 629 615 if (!supported_read_cmd(ssif_bmc->part_buf.smbus_cmd)) { 630 - dev_warn(&ssif_bmc->client->dev, "Warn: Unknown SMBus read command=0x%x", 616 + dev_dbg(&ssif_bmc->client->dev, "Warn: Unknown SMBus read command=0x%x", 631 617 ssif_bmc->part_buf.smbus_cmd); 632 618 ssif_bmc->aborting = true; 633 619 } ··· 662 648 ssif_bmc->state == SSIF_START || 663 649 ssif_bmc->state == SSIF_REQ_RECVING || 664 650 ssif_bmc->state == SSIF_SMBUS_CMD) { 665 - dev_warn(&ssif_bmc->client->dev, 651 + dev_dbg(&ssif_bmc->client->dev, 666 652 "Warn: %s unexpected READ PROCESSED in state=%s\n", 667 653 __func__, state_to_string(ssif_bmc->state)); 668 654 ssif_bmc->state = SSIF_ABORTING; ··· 687 673 } else if (ssif_bmc->state == SSIF_START || 688 674 ssif_bmc->state == SSIF_REQ_RECVING || 689 675 ssif_bmc->state == SSIF_RES_SENDING) { 690 - dev_warn(&ssif_bmc->client->dev, 676 + dev_dbg(&ssif_bmc->client->dev, 691 677 "Warn: %s unexpected WRITE REQUEST in state=%s\n", 692 678 __func__, state_to_string(ssif_bmc->state)); 693 679 ssif_bmc->state = SSIF_ABORTING; ··· 702 688 { 703 689 if (ssif_bmc->state == SSIF_READY || 704 690 ssif_bmc->state == SSIF_RES_SENDING) { 705 - dev_warn(&ssif_bmc->client->dev, 691 + dev_dbg(&ssif_bmc->client->dev, 706 692 "Warn: %s unexpected WRITE RECEIVED in state=%s\n", 707 693 __func__, state_to_string(ssif_bmc->state)); 708 694 ssif_bmc->state = SSIF_ABORTING; ··· 712 698 713 699 } else if (ssif_bmc->state == SSIF_SMBUS_CMD) { 714 700 if (!supported_write_cmd(ssif_bmc->part_buf.smbus_cmd)) { 715 - dev_warn(&ssif_bmc->client->dev, "Warn: Unknown SMBus write command=0x%x", 701 + dev_dbg(&ssif_bmc->client->dev, "Warn: Unknown SMBus write command=0x%x", 716 702 ssif_bmc->part_buf.smbus_cmd); 717 703 ssif_bmc->aborting = true; 718 704 } ··· 721 707 ssif_bmc->state = SSIF_ABORTING; 722 708 else 723 709 ssif_bmc->state = SSIF_REQ_RECVING; 710 + } else if (ssif_bmc->state == SSIF_ABORTING) { 711 + if (supported_write_start_cmd(*val)) { 712 + ssif_bmc->state = SSIF_SMBUS_CMD; 713 + ssif_bmc->aborting = false; 714 + } 724 715 } 725 716 726 717 /* This is response sending state */ ··· 741 722 ssif_bmc->state == SSIF_START || 742 723 ssif_bmc->state == SSIF_SMBUS_CMD || 743 724 ssif_bmc->state == SSIF_ABORTING) { 744 - dev_warn(&ssif_bmc->client->dev, 725 + dev_dbg(&ssif_bmc->client->dev, 745 726 "Warn: %s unexpected SLAVE STOP in state=%s\n", 746 727 __func__, state_to_string(ssif_bmc->state)); 747 728 ssif_bmc->state = SSIF_READY; ··· 808 789 break; 809 790 810 791 default: 811 - dev_warn(&ssif_bmc->client->dev, "Warn: Unknown i2c slave event\n"); 792 + dev_dbg(&ssif_bmc->client->dev, "Warn: Unknown i2c slave event\n"); 812 793 break; 813 794 } 814 795 ··· 862 843 { 863 844 struct ssif_bmc_ctx *ssif_bmc = i2c_get_clientdata(client); 864 845 846 + timer_delete_sync(&ssif_bmc->response_timer); 865 847 i2c_slave_unregister(client); 866 848 misc_deregister(&ssif_bmc->miscdev); 867 849 } ··· 888 868 .remove = ssif_bmc_remove, 889 869 .id_table = ssif_bmc_id, 890 870 }; 871 + 872 + #if IS_ENABLED(CONFIG_SSIF_IPMI_BMC_KUNIT_TEST) 873 + struct ssif_bmc_test_ctx { 874 + struct ssif_bmc_ctx ssif_bmc; 875 + struct i2c_client client; 876 + struct i2c_adapter adapter; 877 + struct i2c_algorithm algo; 878 + }; 879 + 880 + static int ssif_bmc_test_init(struct kunit *test) 881 + { 882 + struct ssif_bmc_test_ctx *test_ctx; 883 + 884 + test_ctx = kunit_kzalloc(test, sizeof(*test_ctx), GFP_KERNEL); 885 + if (!test_ctx) 886 + return -ENOMEM; 887 + 888 + test_ctx->adapter.algo = &test_ctx->algo; 889 + test_ctx->client.addr = 0x20; 890 + test_ctx->client.adapter = &test_ctx->adapter; 891 + 892 + spin_lock_init(&test_ctx->ssif_bmc.lock); 893 + init_waitqueue_head(&test_ctx->ssif_bmc.wait_queue); 894 + test_ctx->ssif_bmc.client = &test_ctx->client; 895 + i2c_set_clientdata(&test_ctx->client, &test_ctx->ssif_bmc); 896 + 897 + test->priv = test_ctx; 898 + 899 + return 0; 900 + } 901 + 902 + static void ssif_bmc_test_exit(struct kunit *test) 903 + { 904 + struct ssif_bmc_test_ctx *test_ctx = test->priv; 905 + 906 + if (test_ctx->ssif_bmc.response_timer_inited) 907 + timer_delete_sync(&test_ctx->ssif_bmc.response_timer); 908 + } 909 + 910 + static int ssif_bmc_test_run_event_val(struct ssif_bmc_test_ctx *test_ctx, 911 + enum i2c_slave_event event, 912 + u8 *value) 913 + { 914 + return ssif_bmc_cb(&test_ctx->client, event, value); 915 + } 916 + 917 + static int ssif_bmc_test_run_event(struct ssif_bmc_test_ctx *test_ctx, 918 + enum i2c_slave_event event, u8 value) 919 + { 920 + return ssif_bmc_test_run_event_val(test_ctx, event, &value); 921 + } 922 + 923 + static void ssif_bmc_test_singlepart_req(struct kunit *test) 924 + { 925 + struct ssif_bmc_test_ctx *test_ctx = test->priv; 926 + struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc; 927 + 928 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED, 929 + GET_8BIT_ADDR(test_ctx->client.addr)); 930 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 931 + SSIF_IPMI_SINGLEPART_WRITE); 932 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 2); 933 + 934 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xaa); 935 + 936 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0x55); 937 + KUNIT_EXPECT_EQ(test, 938 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY); 939 + 940 + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_READY); 941 + KUNIT_EXPECT_TRUE(test, ssif_bmc->request_available); 942 + KUNIT_EXPECT_TRUE(test, ssif_bmc->busy); 943 + KUNIT_EXPECT_FALSE(test, ssif_bmc->aborting); 944 + KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 2); 945 + KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[0], 0xaa); 946 + KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[1], 0x55); 947 + KUNIT_EXPECT_TRUE(test, ssif_bmc->response_timer_inited); 948 + } 949 + 950 + static void ssif_bmc_test_restart_write_without_stop(struct kunit *test) 951 + { 952 + struct ssif_bmc_test_ctx *test_ctx = test->priv; 953 + struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc; 954 + 955 + KUNIT_ASSERT_EQ(test, 956 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED, 957 + GET_8BIT_ADDR(test_ctx->client.addr)), 0); 958 + KUNIT_ASSERT_EQ(test, 959 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 960 + SSIF_IPMI_SINGLEPART_WRITE), 0); 961 + KUNIT_ASSERT_EQ(test, 962 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 2), 0); 963 + KUNIT_ASSERT_EQ(test, 964 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xde), 0); 965 + 966 + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_REQ_RECVING); 967 + 968 + /* Write transaction, without stop, and new request coming */ 969 + ssif_bmc_test_singlepart_req(test); 970 + } 971 + 972 + 973 + static void ssif_bmc_test_restart_after_invalid_command(struct kunit *test) 974 + { 975 + struct ssif_bmc_test_ctx *test_ctx = test->priv; 976 + struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc; 977 + 978 + KUNIT_ASSERT_EQ(test, 979 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED, 980 + GET_8BIT_ADDR(test_ctx->client.addr)), 0); 981 + KUNIT_ASSERT_EQ(test, 982 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xff), 0); 983 + KUNIT_ASSERT_EQ(test, 984 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0); 985 + 986 + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_ABORTING); 987 + KUNIT_EXPECT_TRUE(test, ssif_bmc->aborting); 988 + 989 + /* After An Invalid Command, expect could handle new request */ 990 + ssif_bmc_test_singlepart_req(test); 991 + } 992 + 993 + static void ssif_bmc_test_singlepart_read_response_completion(struct kunit *test) 994 + { 995 + struct ssif_bmc_test_ctx *test_ctx = test->priv; 996 + struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc; 997 + u8 value; 998 + 999 + ssif_bmc->state = SSIF_SMBUS_CMD; 1000 + ssif_bmc->part_buf.smbus_cmd = SSIF_IPMI_SINGLEPART_READ; 1001 + ssif_bmc->response.len = 2; 1002 + ssif_bmc->response.payload[0] = 0x11; 1003 + ssif_bmc->response.payload[1] = 0x22; 1004 + ssif_bmc->response_in_progress = true; 1005 + ssif_bmc->is_singlepart_read = true; 1006 + ssif_bmc->pec_support = true; 1007 + 1008 + value = 0; 1009 + KUNIT_ASSERT_EQ(test, 1010 + ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_REQUESTED, 1011 + &value), 0); 1012 + KUNIT_EXPECT_EQ(test, value, 2); 1013 + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_RES_SENDING); 1014 + 1015 + value = 0; 1016 + KUNIT_EXPECT_EQ(test, 1017 + ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_PROCESSED, 1018 + &value), 0); 1019 + KUNIT_EXPECT_EQ(test, value, 0x11); 1020 + 1021 + value = 0; 1022 + KUNIT_EXPECT_EQ(test, 1023 + ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_PROCESSED, 1024 + &value), 0); 1025 + KUNIT_EXPECT_EQ(test, value, 0x22); 1026 + 1027 + value = 0; 1028 + KUNIT_EXPECT_EQ(test, 1029 + ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_PROCESSED, 1030 + &value), 0); 1031 + KUNIT_EXPECT_EQ(test, value, ssif_bmc->part_buf.pec); 1032 + 1033 + KUNIT_EXPECT_EQ(test, 1034 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), 0); 1035 + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_READY); 1036 + KUNIT_EXPECT_FALSE(test, ssif_bmc->response_in_progress); 1037 + KUNIT_EXPECT_EQ(test, ssif_bmc->response.len, 0); 1038 + } 1039 + 1040 + static void ssif_bmc_test_stop_during_start_discards_partial_request(struct kunit *test) 1041 + { 1042 + struct ssif_bmc_test_ctx *test_ctx = test->priv; 1043 + struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc; 1044 + 1045 + KUNIT_ASSERT_EQ(test, 1046 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED, 1047 + GET_8BIT_ADDR(test_ctx->client.addr)), 0); 1048 + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_START); 1049 + 1050 + KUNIT_EXPECT_EQ(test, 1051 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), 0); 1052 + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_READY); 1053 + KUNIT_EXPECT_FALSE(test, ssif_bmc->request_available); 1054 + KUNIT_EXPECT_EQ(test, ssif_bmc->msg_idx, 0); 1055 + 1056 + KUNIT_EXPECT_EQ(test, 1057 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED, 1058 + GET_8BIT_ADDR(test_ctx->client.addr)), 0); 1059 + KUNIT_EXPECT_EQ(test, 1060 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1061 + SSIF_IPMI_SINGLEPART_WRITE), 0); 1062 + KUNIT_EXPECT_EQ(test, 1063 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0); 1064 + KUNIT_EXPECT_EQ(test, 1065 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0x77), 0); 1066 + KUNIT_EXPECT_EQ(test, 1067 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY); 1068 + 1069 + KUNIT_EXPECT_TRUE(test, ssif_bmc->request_available); 1070 + KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 1); 1071 + KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[0], 0x77); 1072 + } 1073 + 1074 + static void ssif_bmc_test_read_interrupts_partial_write(struct kunit *test) 1075 + { 1076 + struct ssif_bmc_test_ctx *test_ctx = test->priv; 1077 + struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc; 1078 + u8 value = 0xff; 1079 + 1080 + KUNIT_ASSERT_EQ(test, 1081 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED, 1082 + GET_8BIT_ADDR(test_ctx->client.addr)), 0); 1083 + KUNIT_ASSERT_EQ(test, 1084 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1085 + SSIF_IPMI_SINGLEPART_WRITE), 0); 1086 + KUNIT_ASSERT_EQ(test, 1087 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 2), 0); 1088 + KUNIT_ASSERT_EQ(test, 1089 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xab), 0); 1090 + 1091 + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_REQ_RECVING); 1092 + KUNIT_EXPECT_EQ(test, 1093 + ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_REQUESTED, 1094 + &value), 0); 1095 + KUNIT_EXPECT_EQ(test, value, 0); 1096 + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_ABORTING); 1097 + 1098 + KUNIT_EXPECT_EQ(test, 1099 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), 0); 1100 + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_READY); 1101 + KUNIT_EXPECT_FALSE(test, ssif_bmc->request_available); 1102 + KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 0); 1103 + 1104 + KUNIT_EXPECT_EQ(test, 1105 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED, 1106 + GET_8BIT_ADDR(test_ctx->client.addr)), 0); 1107 + KUNIT_EXPECT_EQ(test, 1108 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1109 + SSIF_IPMI_SINGLEPART_WRITE), 0); 1110 + KUNIT_EXPECT_EQ(test, 1111 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0); 1112 + KUNIT_EXPECT_EQ(test, 1113 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xcd), 0); 1114 + KUNIT_EXPECT_EQ(test, 1115 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY); 1116 + 1117 + KUNIT_EXPECT_TRUE(test, ssif_bmc->request_available); 1118 + KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 1); 1119 + KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[0], 0xcd); 1120 + } 1121 + 1122 + static void ssif_bmc_test_write_interrupts_response_send(struct kunit *test) 1123 + { 1124 + struct ssif_bmc_test_ctx *test_ctx = test->priv; 1125 + struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc; 1126 + u8 value = 0; 1127 + 1128 + ssif_bmc->state = SSIF_SMBUS_CMD; 1129 + ssif_bmc->part_buf.smbus_cmd = SSIF_IPMI_SINGLEPART_READ; 1130 + ssif_bmc->response.len = 1; 1131 + ssif_bmc->response.payload[0] = 0x66; 1132 + ssif_bmc->response_in_progress = true; 1133 + ssif_bmc->is_singlepart_read = true; 1134 + 1135 + KUNIT_ASSERT_EQ(test, 1136 + ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_REQUESTED, 1137 + &value), 0); 1138 + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_RES_SENDING); 1139 + 1140 + /* READ_REQUESTED transaction */ 1141 + ssif_bmc_test_singlepart_req(test); 1142 + } 1143 + 1144 + static void ssif_bmc_test_write_interrupts_response_sending(struct kunit *test) 1145 + { 1146 + struct ssif_bmc_test_ctx *test_ctx = test->priv; 1147 + struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc; 1148 + u8 value = 0; 1149 + 1150 + ssif_bmc->state = SSIF_SMBUS_CMD; 1151 + ssif_bmc->part_buf.smbus_cmd = SSIF_IPMI_SINGLEPART_READ; 1152 + ssif_bmc->response.len = 1; 1153 + ssif_bmc->response.payload[0] = 0x66; 1154 + ssif_bmc->response_in_progress = true; 1155 + ssif_bmc->is_singlepart_read = true; 1156 + 1157 + KUNIT_ASSERT_EQ(test, 1158 + ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_REQUESTED, 1159 + &value), 0); 1160 + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_RES_SENDING); 1161 + 1162 + KUNIT_ASSERT_EQ(test, 1163 + ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_PROCESSED, 1164 + &value), 0); 1165 + KUNIT_EXPECT_EQ(test, value, 0x66); 1166 + 1167 + /* READ_REQUESTED transaction */ 1168 + ssif_bmc_test_singlepart_req(test); 1169 + } 1170 + 1171 + static void ssif_bmc_test_timeout_interrupt_allows_retry(struct kunit *test) 1172 + { 1173 + struct ssif_bmc_test_ctx *test_ctx = test->priv; 1174 + struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc; 1175 + 1176 + KUNIT_ASSERT_EQ(test, 1177 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED, 1178 + GET_8BIT_ADDR(test_ctx->client.addr)), 0); 1179 + KUNIT_ASSERT_EQ(test, 1180 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1181 + SSIF_IPMI_SINGLEPART_WRITE), 0); 1182 + KUNIT_ASSERT_EQ(test, 1183 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0); 1184 + KUNIT_ASSERT_EQ(test, 1185 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0x21), 0); 1186 + KUNIT_ASSERT_EQ(test, 1187 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY); 1188 + 1189 + KUNIT_ASSERT_TRUE(test, timer_pending(&ssif_bmc->response_timer)); 1190 + timer_delete_sync(&ssif_bmc->response_timer); 1191 + response_timeout(&ssif_bmc->response_timer); 1192 + 1193 + KUNIT_EXPECT_FALSE(test, ssif_bmc->busy); 1194 + KUNIT_EXPECT_TRUE(test, ssif_bmc->aborting); 1195 + KUNIT_EXPECT_FALSE(test, ssif_bmc->response_timer_inited); 1196 + 1197 + KUNIT_EXPECT_EQ(test, 1198 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED, 1199 + GET_8BIT_ADDR(test_ctx->client.addr)), 0); 1200 + KUNIT_EXPECT_EQ(test, 1201 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1202 + SSIF_IPMI_SINGLEPART_WRITE), 0); 1203 + KUNIT_EXPECT_FALSE(test, ssif_bmc->aborting); 1204 + KUNIT_EXPECT_EQ(test, 1205 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0); 1206 + KUNIT_EXPECT_EQ(test, 1207 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0x22), 0); 1208 + KUNIT_EXPECT_EQ(test, 1209 + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY); 1210 + 1211 + KUNIT_EXPECT_TRUE(test, ssif_bmc->request_available); 1212 + KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 1); 1213 + KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[0], 0x22); 1214 + } 1215 + 1216 + static struct kunit_case ssif_bmc_test_cases[] = { 1217 + KUNIT_CASE(ssif_bmc_test_singlepart_req), 1218 + KUNIT_CASE(ssif_bmc_test_restart_write_without_stop), 1219 + KUNIT_CASE(ssif_bmc_test_restart_after_invalid_command), 1220 + KUNIT_CASE(ssif_bmc_test_singlepart_read_response_completion), 1221 + KUNIT_CASE(ssif_bmc_test_stop_during_start_discards_partial_request), 1222 + KUNIT_CASE(ssif_bmc_test_read_interrupts_partial_write), 1223 + KUNIT_CASE(ssif_bmc_test_write_interrupts_response_send), 1224 + KUNIT_CASE(ssif_bmc_test_write_interrupts_response_sending), 1225 + KUNIT_CASE(ssif_bmc_test_timeout_interrupt_allows_retry), 1226 + {} 1227 + }; 1228 + 1229 + static struct kunit_suite ssif_bmc_test_suite = { 1230 + .name = "ssif_bmc_test", 1231 + .init = ssif_bmc_test_init, 1232 + .exit = ssif_bmc_test_exit, 1233 + .test_cases = ssif_bmc_test_cases, 1234 + }; 1235 + 1236 + kunit_test_suite(ssif_bmc_test_suite); 1237 + #endif 891 1238 892 1239 module_i2c_driver(ssif_bmc_driver); 893 1240

Configure Feed

Configure Feed