tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

staging: unisys: visorbus: Remove POSTCODE_SEVERITY levels

Use the already defined DIAG_SEVERITY values directly instead of special
postcode macro names.

Signed-off-by: Bryan Thompson <bryan.thompson@unisys.com>
Signed-off-by: David Kershner <david.kershner@unisys.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

authored by

Bryan Thompson and committed by
Greg Kroah-Hartman c6bc82f1 a96b44f0

+55 -59
+12 -12
drivers/staging/unisys/visorbus/visorbus_main.c
··· 608 608 u32 chipset_dev_no = dev->chipset_dev_no; 609 609 610 610 POSTCODE_LINUX(DEVICE_CREATE_ENTRY_PC, chipset_dev_no, chipset_bus_no, 611 - POSTCODE_SEVERITY_INFO); 611 + DIAG_SEVERITY_PRINT); 612 612 613 613 mutex_init(&dev->visordriver_callback_lock); 614 614 dev->device.bus = &visorbus_type; ··· 966 966 int err; 967 967 struct spar_vbus_headerinfo *hdr_info; 968 968 969 - POSTCODE_LINUX(BUS_CREATE_ENTRY_PC, 0, 0, POSTCODE_SEVERITY_INFO); 969 + POSTCODE_LINUX(BUS_CREATE_ENTRY_PC, 0, 0, DIAG_SEVERITY_PRINT); 970 970 971 971 hdr_info = kzalloc(sizeof(*hdr_info), GFP_KERNEL); 972 972 if (!hdr_info) ··· 994 994 995 995 if (device_register(&dev->device) < 0) { 996 996 POSTCODE_LINUX(DEVICE_CREATE_FAILURE_PC, 0, id, 997 - POSTCODE_SEVERITY_ERR); 997 + DIAG_SEVERITY_ERR); 998 998 err = -ENODEV; 999 999 goto err_debugfs_created; 1000 1000 } ··· 1092 1092 int rc; 1093 1093 u32 bus_no = dev->chipset_bus_no; 1094 1094 1095 - POSTCODE_LINUX(BUS_CREATE_ENTRY_PC, 0, bus_no, POSTCODE_SEVERITY_INFO); 1095 + POSTCODE_LINUX(BUS_CREATE_ENTRY_PC, 0, bus_no, DIAG_SEVERITY_PRINT); 1096 1096 rc = create_bus_instance(dev); 1097 - POSTCODE_LINUX(BUS_CREATE_EXIT_PC, 0, bus_no, POSTCODE_SEVERITY_INFO); 1097 + POSTCODE_LINUX(BUS_CREATE_EXIT_PC, 0, bus_no, DIAG_SEVERITY_PRINT); 1098 1098 1099 1099 if (rc < 0) 1100 1100 POSTCODE_LINUX(BUS_CREATE_FAILURE_PC, 0, bus_no, 1101 - POSTCODE_SEVERITY_ERR); 1101 + DIAG_SEVERITY_ERR); 1102 1102 else 1103 1103 POSTCODE_LINUX(CHIPSET_INIT_SUCCESS_PC, 0, bus_no, 1104 - POSTCODE_SEVERITY_INFO); 1104 + DIAG_SEVERITY_PRINT); 1105 1105 1106 1106 bus_create_response(dev, rc); 1107 1107 } ··· 1121 1121 u32 dev_no = dev_info->chipset_dev_no; 1122 1122 1123 1123 POSTCODE_LINUX(DEVICE_CREATE_ENTRY_PC, dev_no, bus_no, 1124 - POSTCODE_SEVERITY_INFO); 1124 + DIAG_SEVERITY_PRINT); 1125 1125 1126 1126 rc = create_visor_device(dev_info); 1127 1127 device_create_response(dev_info, rc); 1128 1128 1129 1129 if (rc < 0) 1130 1130 POSTCODE_LINUX(DEVICE_CREATE_FAILURE_PC, dev_no, bus_no, 1131 - POSTCODE_SEVERITY_ERR); 1131 + DIAG_SEVERITY_ERR); 1132 1132 else 1133 1133 POSTCODE_LINUX(DEVICE_CREATE_SUCCESS_PC, dev_no, bus_no, 1134 - POSTCODE_SEVERITY_INFO); 1134 + DIAG_SEVERITY_PRINT); 1135 1135 } 1136 1136 1137 1137 void ··· 1297 1297 { 1298 1298 int err; 1299 1299 1300 - POSTCODE_LINUX(DRIVER_ENTRY_PC, 0, 0, POSTCODE_SEVERITY_INFO); 1300 + POSTCODE_LINUX(DRIVER_ENTRY_PC, 0, 0, DIAG_SEVERITY_PRINT); 1301 1301 1302 1302 visorbus_debugfs_dir = debugfs_create_dir("visorbus", NULL); 1303 1303 if (!visorbus_debugfs_dir) ··· 1316 1316 return 0; 1317 1317 1318 1318 error: 1319 - POSTCODE_LINUX(CHIPSET_INIT_FAILURE_PC, 0, err, POSTCODE_SEVERITY_ERR); 1319 + POSTCODE_LINUX(CHIPSET_INIT_FAILURE_PC, 0, err, DIAG_SEVERITY_ERR); 1320 1320 return err; 1321 1321 } 1322 1322
+43 -43
drivers/staging/unisys/visorbus/visorchipset.c
··· 519 519 int rc = CONTROLVM_RESP_SUCCESS; 520 520 int res = 0; 521 521 522 - POSTCODE_LINUX(CHIPSET_INIT_ENTRY_PC, 0, 0, POSTCODE_SEVERITY_INFO); 522 + POSTCODE_LINUX(CHIPSET_INIT_ENTRY_PC, 0, 0, DIAG_SEVERITY_PRINT); 523 523 if (chipset_inited) { 524 524 rc = -CONTROLVM_RESP_ERROR_ALREADY_DONE; 525 525 res = -EIO; 526 526 goto out_respond; 527 527 } 528 528 chipset_inited = 1; 529 - POSTCODE_LINUX(CHIPSET_INIT_EXIT_PC, 0, 0, POSTCODE_SEVERITY_INFO); 529 + POSTCODE_LINUX(CHIPSET_INIT_EXIT_PC, 0, 0, DIAG_SEVERITY_PRINT); 530 530 531 531 /* 532 532 * Set features to indicate we support parahotplug (if Command ··· 592 592 &local_crash_msg_count, sizeof(u16)); 593 593 if (err) { 594 594 POSTCODE_LINUX(CRASH_DEV_CTRL_RD_FAILURE_PC, 0, 0, 595 - POSTCODE_SEVERITY_ERR); 595 + DIAG_SEVERITY_ERR); 596 596 return err; 597 597 } 598 598 599 599 if (local_crash_msg_count != CONTROLVM_CRASHMSG_MAX) { 600 600 POSTCODE_LINUX(CRASH_DEV_COUNT_FAILURE_PC, 0, 601 601 local_crash_msg_count, 602 - POSTCODE_SEVERITY_ERR); 602 + DIAG_SEVERITY_ERR); 603 603 return -EIO; 604 604 } 605 605 ··· 609 609 &local_crash_msg_offset, sizeof(u32)); 610 610 if (err) { 611 611 POSTCODE_LINUX(CRASH_DEV_CTRL_RD_FAILURE_PC, 0, 0, 612 - POSTCODE_SEVERITY_ERR); 612 + DIAG_SEVERITY_ERR); 613 613 return err; 614 614 } 615 615 ··· 620 620 sizeof(struct controlvm_message)); 621 621 if (err) { 622 622 POSTCODE_LINUX(SAVE_MSG_BUS_FAILURE_PC, 0, 0, 623 - POSTCODE_SEVERITY_ERR); 623 + DIAG_SEVERITY_ERR); 624 624 return err; 625 625 } 626 626 } else { ··· 631 631 sizeof(struct controlvm_message)); 632 632 if (err) { 633 633 POSTCODE_LINUX(SAVE_MSG_DEV_FAILURE_PC, 0, 0, 634 - POSTCODE_SEVERITY_ERR); 634 + DIAG_SEVERITY_ERR); 635 635 return err; 636 636 } 637 637 } ··· 703 703 bus_info = visorbus_get_device_by_id(bus_no, BUS_ROOT_DEVICE, NULL); 704 704 if (bus_info && (bus_info->state.created == 1)) { 705 705 POSTCODE_LINUX(BUS_CREATE_FAILURE_PC, 0, bus_no, 706 - POSTCODE_SEVERITY_ERR); 706 + DIAG_SEVERITY_ERR); 707 707 err = -EEXIST; 708 708 goto err_respond; 709 709 } ··· 711 711 bus_info = kzalloc(sizeof(*bus_info), GFP_KERNEL); 712 712 if (!bus_info) { 713 713 POSTCODE_LINUX(BUS_CREATE_FAILURE_PC, 0, bus_no, 714 - POSTCODE_SEVERITY_ERR); 714 + DIAG_SEVERITY_ERR); 715 715 err = -ENOMEM; 716 716 goto err_respond; 717 717 } ··· 720 720 bus_info->chipset_bus_no = bus_no; 721 721 bus_info->chipset_dev_no = BUS_ROOT_DEVICE; 722 722 723 - POSTCODE_LINUX(BUS_CREATE_ENTRY_PC, 0, bus_no, POSTCODE_SEVERITY_INFO); 723 + POSTCODE_LINUX(BUS_CREATE_ENTRY_PC, 0, bus_no, DIAG_SEVERITY_PRINT); 724 724 725 725 if (uuid_le_cmp(cmd->create_bus.bus_inst_uuid, spar_siovm_uuid) == 0) 726 726 save_crash_message(inmsg, CRASH_BUS); ··· 731 731 if (!pmsg_hdr) { 732 732 POSTCODE_LINUX(MALLOC_FAILURE_PC, cmd, 733 733 bus_info->chipset_bus_no, 734 - POSTCODE_SEVERITY_ERR); 734 + DIAG_SEVERITY_ERR); 735 735 err = -ENOMEM; 736 736 goto err_free_bus_info; 737 737 } ··· 748 748 749 749 if (!visorchannel) { 750 750 POSTCODE_LINUX(BUS_CREATE_FAILURE_PC, 0, bus_no, 751 - POSTCODE_SEVERITY_ERR); 751 + DIAG_SEVERITY_ERR); 752 752 err = -ENOMEM; 753 753 goto err_free_pending_msg; 754 754 } ··· 757 757 /* Response will be handled by chipset_bus_create */ 758 758 chipset_bus_create(bus_info); 759 759 760 - POSTCODE_LINUX(BUS_CREATE_EXIT_PC, 0, bus_no, POSTCODE_SEVERITY_INFO); 760 + POSTCODE_LINUX(BUS_CREATE_EXIT_PC, 0, bus_no, DIAG_SEVERITY_PRINT); 761 761 return 0; 762 762 763 763 err_free_pending_msg: ··· 800 800 if (!pmsg_hdr) { 801 801 POSTCODE_LINUX(MALLOC_FAILURE_PC, cmd, 802 802 bus_info->chipset_bus_no, 803 - POSTCODE_SEVERITY_ERR); 803 + DIAG_SEVERITY_ERR); 804 804 err = -ENOMEM; 805 805 goto err_respond; 806 806 } ··· 831 831 832 832 bus_no = cmd->configure_bus.bus_no; 833 833 POSTCODE_LINUX(BUS_CONFIGURE_ENTRY_PC, 0, bus_no, 834 - POSTCODE_SEVERITY_INFO); 834 + DIAG_SEVERITY_PRINT); 835 835 836 836 bus_info = visorbus_get_device_by_id(bus_no, BUS_ROOT_DEVICE, NULL); 837 837 if (!bus_info) { 838 838 POSTCODE_LINUX(BUS_CONFIGURE_FAILURE_PC, 0, bus_no, 839 - POSTCODE_SEVERITY_ERR); 839 + DIAG_SEVERITY_ERR); 840 840 err = -EINVAL; 841 841 goto err_respond; 842 842 } else if (bus_info->state.created == 0) { 843 843 POSTCODE_LINUX(BUS_CONFIGURE_FAILURE_PC, 0, bus_no, 844 - POSTCODE_SEVERITY_ERR); 844 + DIAG_SEVERITY_ERR); 845 845 err = -EINVAL; 846 846 goto err_respond; 847 847 } else if (bus_info->pending_msg_hdr) { 848 848 POSTCODE_LINUX(BUS_CONFIGURE_FAILURE_PC, 0, bus_no, 849 - POSTCODE_SEVERITY_ERR); 849 + DIAG_SEVERITY_ERR); 850 850 err = -EIO; 851 851 goto err_respond; 852 852 } ··· 862 862 bus_info->name = parser_string_get(parser_ctx); 863 863 864 864 POSTCODE_LINUX(BUS_CONFIGURE_EXIT_PC, 0, bus_no, 865 - POSTCODE_SEVERITY_INFO); 865 + DIAG_SEVERITY_PRINT); 866 866 867 867 if (inmsg->hdr.flags.response_expected == 1) 868 868 bus_responder(inmsg->hdr.id, &inmsg->hdr, err); ··· 889 889 bus_info = visorbus_get_device_by_id(bus_no, BUS_ROOT_DEVICE, NULL); 890 890 if (!bus_info) { 891 891 POSTCODE_LINUX(DEVICE_CREATE_FAILURE_PC, dev_no, bus_no, 892 - POSTCODE_SEVERITY_ERR); 892 + DIAG_SEVERITY_ERR); 893 893 rc = -CONTROLVM_RESP_ERROR_BUS_INVALID; 894 894 goto out_respond; 895 895 } 896 896 897 897 if (bus_info->state.created == 0) { 898 898 POSTCODE_LINUX(DEVICE_CREATE_FAILURE_PC, dev_no, bus_no, 899 - POSTCODE_SEVERITY_ERR); 899 + DIAG_SEVERITY_ERR); 900 900 rc = -CONTROLVM_RESP_ERROR_BUS_INVALID; 901 901 goto out_respond; 902 902 } ··· 904 904 dev_info = visorbus_get_device_by_id(bus_no, dev_no, NULL); 905 905 if (dev_info && (dev_info->state.created == 1)) { 906 906 POSTCODE_LINUX(DEVICE_CREATE_FAILURE_PC, dev_no, bus_no, 907 - POSTCODE_SEVERITY_ERR); 907 + DIAG_SEVERITY_ERR); 908 908 rc = -CONTROLVM_RESP_ERROR_ALREADY_DONE; 909 909 goto out_respond; 910 910 } ··· 912 912 dev_info = kzalloc(sizeof(*dev_info), GFP_KERNEL); 913 913 if (!dev_info) { 914 914 POSTCODE_LINUX(DEVICE_CREATE_FAILURE_PC, dev_no, bus_no, 915 - POSTCODE_SEVERITY_ERR); 915 + DIAG_SEVERITY_ERR); 916 916 rc = -CONTROLVM_RESP_ERROR_KMALLOC_FAILED; 917 917 goto out_respond; 918 918 } ··· 925 925 dev_info->device.parent = &bus_info->device; 926 926 927 927 POSTCODE_LINUX(DEVICE_CREATE_ENTRY_PC, dev_no, bus_no, 928 - POSTCODE_SEVERITY_INFO); 928 + DIAG_SEVERITY_PRINT); 929 929 930 930 visorchannel = 931 931 visorchannel_create_with_lock(cmd->create_device.channel_addr, ··· 935 935 936 936 if (!visorchannel) { 937 937 POSTCODE_LINUX(DEVICE_CREATE_FAILURE_PC, dev_no, bus_no, 938 - POSTCODE_SEVERITY_ERR); 938 + DIAG_SEVERITY_ERR); 939 939 rc = -CONTROLVM_RESP_ERROR_KMALLOC_FAILED; 940 940 goto out_free_dev_info; 941 941 } ··· 959 959 /* Chipset_device_create will send response */ 960 960 chipset_device_create(dev_info); 961 961 POSTCODE_LINUX(DEVICE_CREATE_EXIT_PC, dev_no, bus_no, 962 - POSTCODE_SEVERITY_INFO); 962 + DIAG_SEVERITY_PRINT); 963 963 return; 964 964 965 965 out_free_dev_info: ··· 984 984 dev_info = visorbus_get_device_by_id(bus_no, dev_no, NULL); 985 985 if (!dev_info) { 986 986 POSTCODE_LINUX(DEVICE_CHANGESTATE_FAILURE_PC, dev_no, bus_no, 987 - POSTCODE_SEVERITY_ERR); 987 + DIAG_SEVERITY_ERR); 988 988 rc = -CONTROLVM_RESP_ERROR_DEVICE_INVALID; 989 989 goto err_respond; 990 990 } 991 991 if (dev_info->state.created == 0) { 992 992 POSTCODE_LINUX(DEVICE_CHANGESTATE_FAILURE_PC, dev_no, bus_no, 993 - POSTCODE_SEVERITY_ERR); 993 + DIAG_SEVERITY_ERR); 994 994 rc = -CONTROLVM_RESP_ERROR_DEVICE_INVALID; 995 995 goto err_respond; 996 996 } ··· 1136 1136 request_payload_offset), 1137 1137 &payload_offset, sizeof(payload_offset)) < 0) { 1138 1138 POSTCODE_LINUX(CONTROLVM_INIT_FAILURE_PC, 0, 0, 1139 - POSTCODE_SEVERITY_ERR); 1139 + DIAG_SEVERITY_ERR); 1140 1140 return; 1141 1141 } 1142 1142 if (visorchannel_read(controlvm_channel, ··· 1144 1144 request_payload_bytes), 1145 1145 &payload_bytes, sizeof(payload_bytes)) < 0) { 1146 1146 POSTCODE_LINUX(CONTROLVM_INIT_FAILURE_PC, 0, 0, 1147 - POSTCODE_SEVERITY_ERR); 1147 + DIAG_SEVERITY_ERR); 1148 1148 return; 1149 1149 } 1150 1150 initialize_controlvm_payload_info(phys_addr, ··· 1564 1564 u32 local_crash_msg_offset; 1565 1565 u16 local_crash_msg_count; 1566 1566 1567 - POSTCODE_LINUX(CRASH_DEV_ENTRY_PC, 0, 0, POSTCODE_SEVERITY_INFO); 1567 + POSTCODE_LINUX(CRASH_DEV_ENTRY_PC, 0, 0, DIAG_SEVERITY_PRINT); 1568 1568 1569 1569 /* send init chipset msg */ 1570 1570 msg.hdr.id = CONTROLVM_CHIPSET_INIT; ··· 1579 1579 saved_crash_message_count), 1580 1580 &local_crash_msg_count, sizeof(u16)) < 0) { 1581 1581 POSTCODE_LINUX(CRASH_DEV_CTRL_RD_FAILURE_PC, 0, 0, 1582 - POSTCODE_SEVERITY_ERR); 1582 + DIAG_SEVERITY_ERR); 1583 1583 return; 1584 1584 } 1585 1585 1586 1586 if (local_crash_msg_count != CONTROLVM_CRASHMSG_MAX) { 1587 1587 POSTCODE_LINUX(CRASH_DEV_COUNT_FAILURE_PC, 0, 1588 1588 local_crash_msg_count, 1589 - POSTCODE_SEVERITY_ERR); 1589 + DIAG_SEVERITY_ERR); 1590 1590 return; 1591 1591 } 1592 1592 ··· 1596 1596 saved_crash_message_offset), 1597 1597 &local_crash_msg_offset, sizeof(u32)) < 0) { 1598 1598 POSTCODE_LINUX(CRASH_DEV_CTRL_RD_FAILURE_PC, 0, 0, 1599 - POSTCODE_SEVERITY_ERR); 1599 + DIAG_SEVERITY_ERR); 1600 1600 return; 1601 1601 } 1602 1602 ··· 1606 1606 &local_crash_bus_msg, 1607 1607 sizeof(struct controlvm_message)) < 0) { 1608 1608 POSTCODE_LINUX(CRASH_DEV_RD_BUS_FAILURE_PC, 0, 0, 1609 - POSTCODE_SEVERITY_ERR); 1609 + DIAG_SEVERITY_ERR); 1610 1610 return; 1611 1611 } 1612 1612 ··· 1617 1617 &local_crash_dev_msg, 1618 1618 sizeof(struct controlvm_message)) < 0) { 1619 1619 POSTCODE_LINUX(CRASH_DEV_RD_DEV_FAILURE_PC, 0, 0, 1620 - POSTCODE_SEVERITY_ERR); 1620 + DIAG_SEVERITY_ERR); 1621 1621 return; 1622 1622 } 1623 1623 ··· 1626 1626 bus_create(&local_crash_bus_msg); 1627 1627 } else { 1628 1628 POSTCODE_LINUX(CRASH_DEV_BUS_NULL_FAILURE_PC, 0, 0, 1629 - POSTCODE_SEVERITY_ERR); 1629 + DIAG_SEVERITY_ERR); 1630 1630 return; 1631 1631 } 1632 1632 ··· 1635 1635 my_device_create(&local_crash_dev_msg); 1636 1636 } else { 1637 1637 POSTCODE_LINUX(CRASH_DEV_DEV_NULL_FAILURE_PC, 0, 0, 1638 - POSTCODE_SEVERITY_ERR); 1638 + DIAG_SEVERITY_ERR); 1639 1639 return; 1640 1640 } 1641 - POSTCODE_LINUX(CRASH_DEV_EXIT_PC, 0, 0, POSTCODE_SEVERITY_INFO); 1641 + POSTCODE_LINUX(CRASH_DEV_EXIT_PC, 0, 0, DIAG_SEVERITY_PRINT); 1642 1642 } 1643 1643 1644 1644 void ··· 2179 2179 err = -ENODEV; 2180 2180 goto error_cancel_work; 2181 2181 } 2182 - POSTCODE_LINUX(CHIPSET_INIT_SUCCESS_PC, 0, 0, POSTCODE_SEVERITY_INFO); 2182 + POSTCODE_LINUX(CHIPSET_INIT_SUCCESS_PC, 0, 0, DIAG_SEVERITY_PRINT); 2183 2183 2184 2184 err = visorbus_init(); 2185 2185 if (err < 0) ··· 2201 2201 visorchannel_destroy(controlvm_channel); 2202 2202 2203 2203 error: 2204 - POSTCODE_LINUX(CHIPSET_INIT_FAILURE_PC, 0, err, POSTCODE_SEVERITY_ERR); 2204 + POSTCODE_LINUX(CHIPSET_INIT_FAILURE_PC, 0, err, DIAG_SEVERITY_ERR); 2205 2205 return err; 2206 2206 } 2207 2207 2208 2208 static int 2209 2209 visorchipset_exit(struct acpi_device *acpi_device) 2210 2210 { 2211 - POSTCODE_LINUX(DRIVER_EXIT_PC, 0, 0, POSTCODE_SEVERITY_INFO); 2211 + POSTCODE_LINUX(DRIVER_EXIT_PC, 0, 0, DIAG_SEVERITY_PRINT); 2212 2212 2213 2213 visorbus_exit(); 2214 2214 ··· 2219 2219 2220 2220 visorchipset_file_cleanup(visorchipset_platform_device.dev.devt); 2221 2221 platform_device_unregister(&visorchipset_platform_device); 2222 - POSTCODE_LINUX(DRIVER_EXIT_PC, 0, 0, POSTCODE_SEVERITY_INFO); 2222 + POSTCODE_LINUX(DRIVER_EXIT_PC, 0, 0, DIAG_SEVERITY_PRINT); 2223 2223 2224 2224 return 0; 2225 2225 }
-4
drivers/staging/unisys/visorbus/vmcallinterface.h
··· 157 157 SAVE_MSG_DEV_FAILURE_PC = 0x01F, 158 158 }; 159 159 160 - #define POSTCODE_SEVERITY_ERR DIAG_SEVERITY_ERR 161 - /* TODO-> Info currently doesn't show, so we set info=warning */ 162 - #define POSTCODE_SEVERITY_INFO DIAG_SEVERITY_PRINT 163 - 164 160 /* Write a 64-bit value to the hypervisor's log file 165 161 * POSTCODE_LINUX generates a value in the form 0xAABBBCCCDDDDEEEE where 166 162 * A is an identifier for the file logging the postcode