drivers/firewire/packet-serdes-test.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 //
   3 // packet-serdes-test.c - An application of Kunit to check serialization/deserialization of packets
   4 //                        defined by IEEE 1394.
   5 //
   6 // Copyright (c) 2024 Takashi Sakamoto
   7
   8 #include <kunit/test.h>
   9
  10 #include <linux/firewire-constants.h>
  11
  12 #include "packet-header-definitions.h"
  13 #include "phy-packet-definitions.h"
  14
  15 static void serialize_async_header_common(u32 header[ASYNC_HEADER_QUADLET_COUNT],
  16                                           unsigned int dst_id, unsigned int tlabel,
  17                                           unsigned int retry, unsigned int tcode,
  18                                           unsigned int priority, unsigned int src_id)
  19 {
  20         async_header_set_destination(header, dst_id);
  21         async_header_set_tlabel(header, tlabel);
  22         async_header_set_retry(header, retry);
  23         async_header_set_tcode(header, tcode);
  24         async_header_set_priority(header, priority);
  25         async_header_set_source(header, src_id);
  26 }
  27
  28 static void serialize_async_header_request(u32 header[ASYNC_HEADER_QUADLET_COUNT],
  29                                            unsigned int dst_id, unsigned int tlabel,
  30                                            unsigned int retry, unsigned int tcode,
  31                                            unsigned int priority, unsigned int src_id, u64 offset)
  32 {
  33         serialize_async_header_common(header, dst_id, tlabel, retry, tcode, priority, src_id);
  34         async_header_set_offset(header, offset);
  35 }
  36
  37 static void serialize_async_header_quadlet_request(u32 header[ASYNC_HEADER_QUADLET_COUNT],
  38                                                    unsigned int dst_id, unsigned int tlabel,
  39                                                    unsigned int retry, unsigned int tcode,
  40                                                    unsigned int priority, unsigned int src_id,
  41                                                    u64 offset)
  42 {
  43         serialize_async_header_request(header, dst_id, tlabel, retry, tcode, priority, src_id,
  44                                        offset);
  45 }
  46
  47 static void serialize_async_header_block_request(u32 header[ASYNC_HEADER_QUADLET_COUNT],
  48                                                  unsigned int dst_id, unsigned int tlabel,
  49                                                  unsigned int retry, unsigned int tcode,
  50                                                  unsigned int priority, unsigned int src_id,
  51                                                  u64 offset, unsigned int data_length,
  52                                                  unsigned int extended_tcode)
  53 {
  54         serialize_async_header_request(header, dst_id, tlabel, retry, tcode, priority, src_id,
  55                                        offset);
  56         async_header_set_data_length(header, data_length);
  57         async_header_set_extended_tcode(header, extended_tcode);
  58 }
  59
  60 static void serialize_async_header_response(u32 header[ASYNC_HEADER_QUADLET_COUNT],
  61                                             unsigned int dst_id, unsigned int tlabel,
  62                                             unsigned int retry, unsigned int tcode,
  63                                             unsigned int priority, unsigned int src_id,
  64                                             unsigned int rcode)
  65 {
  66         serialize_async_header_common(header, dst_id, tlabel, retry, tcode, priority, src_id);
  67         async_header_set_rcode(header, rcode);
  68 }
  69
  70 static void serialize_async_header_quadlet_response(u32 header[ASYNC_HEADER_QUADLET_COUNT],
  71                                                     unsigned int dst_id, unsigned int tlabel,
  72                                                     unsigned int retry, unsigned int tcode,
  73                                                     unsigned int priority, unsigned int src_id,
  74                                                     unsigned int rcode)
  75 {
  76         serialize_async_header_response(header, dst_id, tlabel, retry, tcode, priority, src_id,
  77                                         rcode);
  78 }
  79
  80 static void serialize_async_header_block_response(u32 header[ASYNC_HEADER_QUADLET_COUNT],
  81                                                   unsigned int dst_id, unsigned int tlabel,
  82                                                   unsigned int retry, unsigned int tcode,
  83                                                   unsigned int priority, unsigned int src_id,
  84                                                   unsigned int rcode, unsigned int data_length,
  85                                                   unsigned int extended_tcode)
  86 {
  87         serialize_async_header_response(header, dst_id, tlabel, retry, tcode, priority, src_id,
  88                                         rcode);
  89         async_header_set_data_length(header, data_length);
  90         async_header_set_extended_tcode(header, extended_tcode);
  91 }
  92
  93 static void deserialize_async_header_common(const u32 header[ASYNC_HEADER_QUADLET_COUNT],
  94                                             unsigned int *dst_id, unsigned int *tlabel,
  95                                             unsigned int *retry, unsigned int *tcode,
  96                                             unsigned int *priority, unsigned int *src_id)
  97 {
  98         *dst_id = async_header_get_destination(header);
  99         *tlabel = async_header_get_tlabel(header);
 100         *retry = async_header_get_retry(header);
 101         *tcode = async_header_get_tcode(header);
 102         *priority = async_header_get_priority(header);
 103         *src_id = async_header_get_source(header);
 104 }
 105
 106 static void deserialize_async_header_request(const u32 header[ASYNC_HEADER_QUADLET_COUNT],
 107                                              unsigned int *dst_id, unsigned int *tlabel,
 108                                              unsigned int *retry, unsigned int *tcode,
 109                                              unsigned int *priority, unsigned int *src_id,
 110                                              u64 *offset)
 111 {
 112         deserialize_async_header_common(header, dst_id, tlabel, retry, tcode, priority, src_id);
 113         *offset = async_header_get_offset(header);
 114 }
 115
 116 static void deserialize_async_header_quadlet_request(const u32 header[ASYNC_HEADER_QUADLET_COUNT],
 117                                                      unsigned int *dst_id, unsigned int *tlabel,
 118                                                      unsigned int *retry, unsigned int *tcode,
 119                                                      unsigned int *priority, unsigned int *src_id,
 120                                                      u64 *offset)
 121 {
 122         deserialize_async_header_request(header, dst_id, tlabel, retry, tcode, priority, src_id,
 123                                          offset);
 124 }
 125
 126 static void deserialize_async_header_block_request(const u32 header[ASYNC_HEADER_QUADLET_COUNT],
 127                                                    unsigned int *dst_id, unsigned int *tlabel,
 128                                                    unsigned int *retry, unsigned int *tcode,
 129                                                    unsigned int *priority, unsigned int *src_id,
 130                                                    u64 *offset,
 131                                                    unsigned int *data_length,
 132                                                    unsigned int *extended_tcode)
 133 {
 134         deserialize_async_header_request(header, dst_id, tlabel, retry, tcode, priority, src_id,
 135                                          offset);
 136         *data_length = async_header_get_data_length(header);
 137         *extended_tcode = async_header_get_extended_tcode(header);
 138 }
 139
 140 static void deserialize_async_header_response(const u32 header[ASYNC_HEADER_QUADLET_COUNT],
 141                                               unsigned int *dst_id, unsigned int *tlabel,
 142                                               unsigned int *retry, unsigned int *tcode,
 143                                               unsigned int *priority, unsigned int *src_id,
 144                                               unsigned int *rcode)
 145 {
 146         deserialize_async_header_common(header, dst_id, tlabel, retry, tcode, priority, src_id);
 147         *rcode = async_header_get_rcode(header);
 148 }
 149
 150 static void deserialize_async_header_quadlet_response(const u32 header[ASYNC_HEADER_QUADLET_COUNT],
 151                                                       unsigned int *dst_id, unsigned int *tlabel,
 152                                                       unsigned int *retry, unsigned int *tcode,
 153                                                       unsigned int *priority, unsigned int *src_id,
 154                                                       unsigned int *rcode)
 155 {
 156         deserialize_async_header_response(header, dst_id, tlabel, retry, tcode, priority, src_id, rcode);
 157 }
 158
 159 static void deserialize_async_header_block_response(const u32 header[ASYNC_HEADER_QUADLET_COUNT],
 160                                                     unsigned int *dst_id, unsigned int *tlabel,
 161                                                     unsigned int *retry, unsigned int *tcode,
 162                                                     unsigned int *priority, unsigned int *src_id,
 163                                                     unsigned int *rcode, unsigned int *data_length,
 164                                                     unsigned int *extended_tcode)
 165 {
 166         deserialize_async_header_response(header, dst_id, tlabel, retry, tcode, priority, src_id, rcode);
 167         *data_length = async_header_get_data_length(header);
 168         *extended_tcode = async_header_get_extended_tcode(header);
 169 }
 170
 171 static void serialize_isoc_header(u32 *header, unsigned int data_length, unsigned int tag,
 172                                   unsigned int channel, unsigned int tcode, unsigned int sy)
 173 {
 174         isoc_header_set_data_length(header, data_length);
 175         isoc_header_set_tag(header, tag);
 176         isoc_header_set_channel(header, channel);
 177         isoc_header_set_tcode(header, tcode);
 178         isoc_header_set_sy(header, sy);
 179 }
 180
 181 static void deserialize_isoc_header(u32 header, unsigned int *data_length, unsigned int *tag,
 182                                     unsigned int *channel, unsigned int *tcode, unsigned int *sy)
 183 {
 184         *data_length = isoc_header_get_data_length(header);
 185         *tag = isoc_header_get_tag(header);
 186         *channel = isoc_header_get_channel(header);
 187         *tcode = isoc_header_get_tcode(header);
 188         *sy = isoc_header_get_sy(header);
 189 }
 190
 191 static void serialize_phy_packet_self_id_zero(u32 *quadlet, unsigned int packet_identifier,
 192                                               unsigned int phy_id, bool extended,
 193                                               bool link_is_active, unsigned int gap_count,
 194                                               unsigned int scode, bool is_contender,
 195                                               unsigned int power_class, bool is_initiated_reset,
 196                                               bool has_more_packets)
 197 {
 198         phy_packet_set_packet_identifier(quadlet, packet_identifier);
 199         phy_packet_self_id_set_phy_id(quadlet, phy_id);
 200         phy_packet_self_id_set_extended(quadlet, extended);
 201         phy_packet_self_id_zero_set_link_active(quadlet, link_is_active);
 202         phy_packet_self_id_zero_set_gap_count(quadlet, gap_count);
 203         phy_packet_self_id_zero_set_scode(quadlet, scode);
 204         phy_packet_self_id_zero_set_contender(quadlet, is_contender);
 205         phy_packet_self_id_zero_set_power_class(quadlet, power_class);
 206         phy_packet_self_id_zero_set_initiated_reset(quadlet, is_initiated_reset);
 207         phy_packet_self_id_set_more_packets(quadlet, has_more_packets);
 208 }
 209
 210 static void deserialize_phy_packet_self_id_zero(u32 quadlet, unsigned int *packet_identifier,
 211                                                 unsigned int *phy_id, bool *extended,
 212                                                 bool *link_is_active, unsigned int *gap_count,
 213                                                 unsigned int *scode, bool *is_contender,
 214                                                 unsigned int *power_class,
 215                                                 bool *is_initiated_reset, bool *has_more_packets)
 216 {
 217         *packet_identifier = phy_packet_get_packet_identifier(quadlet);
 218         *phy_id = phy_packet_self_id_get_phy_id(quadlet);
 219         *extended = phy_packet_self_id_get_extended(quadlet);
 220         *link_is_active = phy_packet_self_id_zero_get_link_active(quadlet);
 221         *gap_count = phy_packet_self_id_zero_get_gap_count(quadlet);
 222         *scode = phy_packet_self_id_zero_get_scode(quadlet);
 223         *is_contender = phy_packet_self_id_zero_get_contender(quadlet);
 224         *power_class = phy_packet_self_id_zero_get_power_class(quadlet);
 225         *is_initiated_reset = phy_packet_self_id_zero_get_initiated_reset(quadlet);
 226         *has_more_packets = phy_packet_self_id_get_more_packets(quadlet);
 227 }
 228
 229 static void serialize_phy_packet_self_id_extended(u32 *quadlet, unsigned int packet_identifier,
 230                                                   unsigned int phy_id, bool extended,
 231                                                   unsigned int sequence, bool has_more_packets)
 232 {
 233         phy_packet_set_packet_identifier(quadlet, packet_identifier);
 234         phy_packet_self_id_set_phy_id(quadlet, phy_id);
 235         phy_packet_self_id_set_extended(quadlet, extended);
 236         phy_packet_self_id_extended_set_sequence(quadlet, sequence);
 237         phy_packet_self_id_set_more_packets(quadlet, has_more_packets);
 238 }
 239
 240 static void deserialize_phy_packet_self_id_extended(u32 quadlet, unsigned int *packet_identifier,
 241                                                     unsigned int *phy_id, bool *extended,
 242                                                     unsigned int *sequence, bool *has_more_packets)
 243 {
 244         *packet_identifier = phy_packet_get_packet_identifier(quadlet);
 245         *phy_id = phy_packet_self_id_get_phy_id(quadlet);
 246         *extended = phy_packet_self_id_get_extended(quadlet);
 247         *sequence = phy_packet_self_id_extended_get_sequence(quadlet);
 248         *has_more_packets = phy_packet_self_id_get_more_packets(quadlet);
 249 }
 250
 251 static void serialize_phy_packet_phy_config(u32 *quadlet, unsigned int packet_identifier,
 252                                             unsigned int root_id, bool has_force_root_node,
 253                                             bool has_gap_count_optimization, unsigned int gap_count)
 254 {
 255         phy_packet_set_packet_identifier(quadlet, packet_identifier);
 256         phy_packet_phy_config_set_root_id(quadlet, root_id);
 257         phy_packet_phy_config_set_force_root_node(quadlet, has_force_root_node);
 258         phy_packet_phy_config_set_gap_count_optimization(quadlet, has_gap_count_optimization);
 259         phy_packet_phy_config_set_gap_count(quadlet, gap_count);
 260 }
 261
 262 static void deserialize_phy_packet_phy_config(u32 quadlet, unsigned int *packet_identifier,
 263                                               unsigned int *root_id, bool *has_force_root_node,
 264                                               bool *has_gap_count_optimization,
 265                                               unsigned int *gap_count)
 266 {
 267         *packet_identifier = phy_packet_get_packet_identifier(quadlet);
 268         *root_id = phy_packet_phy_config_get_root_id(quadlet);
 269         *has_force_root_node = phy_packet_phy_config_get_force_root_node(quadlet);
 270         *has_gap_count_optimization = phy_packet_phy_config_get_gap_count_optimization(quadlet);
 271         *gap_count = phy_packet_phy_config_get_gap_count(quadlet);
 272 }
 273
 274 static void test_async_header_write_quadlet_request(struct kunit *test)
 275 {
 276         static const u32 expected[ASYNC_HEADER_QUADLET_COUNT] = {
 277                 0xffc05100,
 278                 0xffc1ffff,
 279                 0xf0000234,
 280                 0x1f0000c0,
 281         };
 282         u32 header[ASYNC_HEADER_QUADLET_COUNT] = {0, 0, 0, 0};
 283
 284         unsigned int dst_id;
 285         unsigned int tlabel;
 286         unsigned int retry;
 287         unsigned int tcode;
 288         unsigned int priority;
 289         unsigned int src_id;
 290         u64 offset;
 291         u32 quadlet_data;
 292
 293         deserialize_async_header_quadlet_request(expected, &dst_id, &tlabel, &retry, &tcode,
 294                                                  &priority, &src_id, &offset);
 295         quadlet_data = async_header_get_quadlet_data(expected);
 296
 297         KUNIT_EXPECT_EQ(test, 0xffc0, dst_id);
 298         KUNIT_EXPECT_EQ(test, 0x14, tlabel);
 299         KUNIT_EXPECT_EQ(test, 0x01, retry);
 300         KUNIT_EXPECT_EQ(test, TCODE_WRITE_QUADLET_REQUEST, tcode);
 301         KUNIT_EXPECT_EQ(test, 0x00, priority);
 302         KUNIT_EXPECT_EQ(test, 0xffc1, src_id);
 303         KUNIT_EXPECT_EQ(test, 0xfffff0000234, offset);
 304         KUNIT_EXPECT_EQ(test, 0x1f0000c0, quadlet_data);
 305
 306         serialize_async_header_quadlet_request(header, dst_id, tlabel, retry, tcode, priority,
 307                                                src_id, offset);
 308         async_header_set_quadlet_data(header, quadlet_data);
 309
 310         KUNIT_EXPECT_MEMEQ(test, header, expected, sizeof(expected));
 311 }
 312
 313 static void test_async_header_write_block_request(struct kunit *test)
 314 {
 315         static const u32 expected[ASYNC_HEADER_QUADLET_COUNT] = {
 316                 0xffc06510,
 317                 0xffc1ecc0,
 318                 0x00000000,
 319                 0x00180000,
 320         };
 321         u32 header[ASYNC_HEADER_QUADLET_COUNT] = {0, 0, 0, 0};
 322
 323         unsigned int dst_id;
 324         unsigned int tlabel;
 325         unsigned int retry;
 326         unsigned int tcode;
 327         unsigned int priority;
 328         unsigned int src_id;
 329         u64 offset;
 330         unsigned int data_length;
 331         unsigned int extended_tcode;
 332
 333         deserialize_async_header_block_request(expected, &dst_id, &tlabel, &retry, &tcode,
 334                                                &priority, &src_id, &offset, &data_length,
 335                                                &extended_tcode);
 336
 337         KUNIT_EXPECT_EQ(test, 0xffc0, dst_id);
 338         KUNIT_EXPECT_EQ(test, 0x19, tlabel);
 339         KUNIT_EXPECT_EQ(test, 0x01, retry);
 340         KUNIT_EXPECT_EQ(test, TCODE_WRITE_BLOCK_REQUEST, tcode);
 341         KUNIT_EXPECT_EQ(test, 0x00, priority);
 342         KUNIT_EXPECT_EQ(test, 0xffc1, src_id);
 343         KUNIT_EXPECT_EQ(test, 0xecc000000000, offset);
 344         KUNIT_EXPECT_EQ(test, 0x0018, data_length);
 345         KUNIT_EXPECT_EQ(test, 0x0000, extended_tcode);
 346
 347         serialize_async_header_block_request(header, dst_id, tlabel, retry, tcode, priority, src_id,
 348                                              offset, data_length, extended_tcode);
 349
 350         KUNIT_EXPECT_MEMEQ(test, header, expected, sizeof(expected));
 351 }
 352
 353 static void test_async_header_write_response(struct kunit *test)
 354 {
 355         static const u32 expected[ASYNC_HEADER_QUADLET_COUNT] = {
 356                 0xffc15120,
 357                 0xffc00000,
 358                 0x00000000,
 359                 0x00000000,
 360         };
 361         u32 header[ASYNC_HEADER_QUADLET_COUNT] = {0, 0, 0, 0};
 362
 363         unsigned int dst_id;
 364         unsigned int tlabel;
 365         unsigned int retry;
 366         unsigned int tcode;
 367         unsigned int priority;
 368         unsigned int src_id;
 369         unsigned int rcode;
 370
 371         deserialize_async_header_quadlet_response(expected, &dst_id, &tlabel, &retry, &tcode,
 372                                                   &priority, &src_id, &rcode);
 373
 374         KUNIT_EXPECT_EQ(test, 0xffc1, dst_id);
 375         KUNIT_EXPECT_EQ(test, 0x14, tlabel);
 376         KUNIT_EXPECT_EQ(test, 0x01, retry);
 377         KUNIT_EXPECT_EQ(test, TCODE_WRITE_RESPONSE, tcode);
 378         KUNIT_EXPECT_EQ(test, 0x00, priority);
 379         KUNIT_EXPECT_EQ(test, 0xffc0, src_id);
 380         KUNIT_EXPECT_EQ(test, RCODE_COMPLETE, rcode);
 381
 382         serialize_async_header_quadlet_response(header, dst_id, tlabel, retry, tcode, priority,
 383                                                 src_id, rcode);
 384
 385         KUNIT_EXPECT_MEMEQ(test, header, expected, sizeof(expected) - sizeof(expected[0]));
 386 }
 387
 388 static void test_async_header_read_quadlet_request(struct kunit *test)
 389 {
 390         static const u32 expected[ASYNC_HEADER_QUADLET_COUNT] = {
 391                 0xffc0f140,
 392                 0xffc1ffff,
 393                 0xf0000984,
 394                 0x00000000,
 395         };
 396         u32 header[ASYNC_HEADER_QUADLET_COUNT] = {0, 0, 0, 0};
 397
 398         unsigned int dst_id;
 399         unsigned int tlabel;
 400         unsigned int retry;
 401         unsigned int tcode;
 402         unsigned int priority;
 403         unsigned int src_id;
 404         u64 offset;
 405
 406         deserialize_async_header_quadlet_request(expected, &dst_id, &tlabel, &retry, &tcode,
 407                                                  &priority, &src_id, &offset);
 408
 409         KUNIT_EXPECT_EQ(test, 0xffc0, dst_id);
 410         KUNIT_EXPECT_EQ(test, 0x3c, tlabel);
 411         KUNIT_EXPECT_EQ(test, 0x01, retry);
 412         KUNIT_EXPECT_EQ(test, TCODE_READ_QUADLET_REQUEST, tcode);
 413         KUNIT_EXPECT_EQ(test, 0x00, priority);
 414         KUNIT_EXPECT_EQ(test, 0xffc1, src_id);
 415         KUNIT_EXPECT_EQ(test, 0xfffff0000984, offset);
 416
 417         serialize_async_header_quadlet_request(header, dst_id, tlabel, retry, tcode, priority,
 418                                                src_id, offset);
 419
 420         KUNIT_EXPECT_MEMEQ(test, header, expected, sizeof(expected));
 421 }
 422
 423 static void test_async_header_read_quadlet_response(struct kunit *test)
 424 {
 425         static const u32 expected[ASYNC_HEADER_QUADLET_COUNT] = {
 426                 0xffc1f160,
 427                 0xffc00000,
 428                 0x00000000,
 429                 0x00000180,
 430         };
 431         u32 header[ASYNC_HEADER_QUADLET_COUNT] = {0, 0, 0, 0};
 432
 433         unsigned int dst_id;
 434         unsigned int tlabel;
 435         unsigned int retry;
 436         unsigned int tcode;
 437         unsigned int priority;
 438         unsigned int src_id;
 439         unsigned int rcode;
 440         u32 quadlet_data;
 441
 442         deserialize_async_header_quadlet_response(expected, &dst_id, &tlabel, &retry, &tcode,
 443                                                   &priority, &src_id, &rcode);
 444         quadlet_data = async_header_get_quadlet_data(expected);
 445
 446         KUNIT_EXPECT_EQ(test, 0xffc1, dst_id);
 447         KUNIT_EXPECT_EQ(test, 0x3c, tlabel);
 448         KUNIT_EXPECT_EQ(test, 0x01, retry);
 449         KUNIT_EXPECT_EQ(test, TCODE_READ_QUADLET_RESPONSE, tcode);
 450         KUNIT_EXPECT_EQ(test, 0x00, priority);
 451         KUNIT_EXPECT_EQ(test, 0xffc0, src_id);
 452         KUNIT_EXPECT_EQ(test, RCODE_COMPLETE, rcode);
 453         KUNIT_EXPECT_EQ(test, 0x00000180, quadlet_data);
 454
 455         serialize_async_header_quadlet_response(header, dst_id, tlabel, retry, tcode, priority,
 456                                                 src_id, rcode);
 457         async_header_set_quadlet_data(header, quadlet_data);
 458
 459         KUNIT_EXPECT_MEMEQ(test, header, expected, sizeof(expected));
 460 }
 461
 462 static void test_async_header_read_block_request(struct kunit *test)
 463 {
 464         static const u32 expected[ASYNC_HEADER_QUADLET_COUNT] = {
 465                 0xffc0e150,
 466                 0xffc1ffff,
 467                 0xf0000400,
 468                 0x00200000,
 469         };
 470         u32 header[ASYNC_HEADER_QUADLET_COUNT] = {0, 0, 0, 0};
 471
 472         unsigned int dst_id;
 473         unsigned int tlabel;
 474         unsigned int retry;
 475         unsigned int tcode;
 476         unsigned int priority;
 477         unsigned int src_id;
 478         u64 offset;
 479         unsigned int data_length;
 480         unsigned int extended_tcode;
 481
 482         deserialize_async_header_block_request(expected, &dst_id, &tlabel, &retry, &tcode,
 483                                                &priority, &src_id, &offset, &data_length,
 484                                                &extended_tcode);
 485
 486         KUNIT_EXPECT_EQ(test, 0xffc0, dst_id);
 487         KUNIT_EXPECT_EQ(test, 0x38, tlabel);
 488         KUNIT_EXPECT_EQ(test, 0x01, retry);
 489         KUNIT_EXPECT_EQ(test, TCODE_READ_BLOCK_REQUEST, tcode);
 490         KUNIT_EXPECT_EQ(test, 0x00, priority);
 491         KUNIT_EXPECT_EQ(test, 0xffc1, src_id);
 492         KUNIT_EXPECT_EQ(test, 0xfffff0000400, offset);
 493         KUNIT_EXPECT_EQ(test, 0x0020, data_length);
 494         KUNIT_EXPECT_EQ(test, 0x0000, extended_tcode);
 495
 496         serialize_async_header_block_request(header, dst_id, tlabel, retry, tcode, priority, src_id,
 497                                              offset, data_length, extended_tcode);
 498
 499         KUNIT_EXPECT_MEMEQ(test, header, expected, sizeof(expected));
 500 }
 501
 502 static void test_async_header_read_block_response(struct kunit *test)
 503 {
 504         static const u32 expected[ASYNC_HEADER_QUADLET_COUNT] = {
 505                 0xffc1e170,
 506                 0xffc00000,
 507                 0x00000000,
 508                 0x00200000,
 509         };
 510         u32 header[ASYNC_HEADER_QUADLET_COUNT] = {0, 0, 0, 0};
 511
 512         unsigned int dst_id;
 513         unsigned int tlabel;
 514         unsigned int retry;
 515         unsigned int tcode;
 516         unsigned int priority;
 517         unsigned int src_id;
 518         unsigned int rcode;
 519         unsigned int data_length;
 520         unsigned int extended_tcode;
 521
 522         deserialize_async_header_block_response(expected, &dst_id, &tlabel, &retry, &tcode,
 523                                                 &priority, &src_id, &rcode, &data_length,
 524                                                 &extended_tcode);
 525
 526         KUNIT_EXPECT_EQ(test, 0xffc1, dst_id);
 527         KUNIT_EXPECT_EQ(test, 0x38, tlabel);
 528         KUNIT_EXPECT_EQ(test, 0x01, retry);
 529         KUNIT_EXPECT_EQ(test, TCODE_READ_BLOCK_RESPONSE, tcode);
 530         KUNIT_EXPECT_EQ(test, 0x00, priority);
 531         KUNIT_EXPECT_EQ(test, 0xffc0, src_id);
 532         KUNIT_EXPECT_EQ(test, RCODE_COMPLETE, rcode);
 533         KUNIT_EXPECT_EQ(test, 0x0020, data_length);
 534         KUNIT_EXPECT_EQ(test, 0x0000, extended_tcode);
 535
 536         serialize_async_header_block_response(header, dst_id, tlabel, retry, tcode, priority,
 537                                               src_id, rcode, data_length, extended_tcode);
 538
 539         KUNIT_EXPECT_MEMEQ(test, header, expected, sizeof(expected));
 540 }
 541
 542 static void test_async_header_lock_request(struct kunit *test)
 543 {
 544         static const u32 expected[ASYNC_HEADER_QUADLET_COUNT] = {
 545                 0xffc02d90,
 546                 0xffc1ffff,
 547                 0xf0000984,
 548                 0x00080002,
 549         };
 550         u32 header[ASYNC_HEADER_QUADLET_COUNT] = {0, 0, 0, 0};
 551
 552         unsigned int dst_id;
 553         unsigned int tlabel;
 554         unsigned int retry;
 555         unsigned int tcode;
 556         unsigned int priority;
 557         unsigned int src_id;
 558         u64 offset;
 559         unsigned int data_length;
 560         unsigned int extended_tcode;
 561
 562         deserialize_async_header_block_request(expected, &dst_id, &tlabel, &retry, &tcode,
 563                                                &priority, &src_id, &offset, &data_length,
 564                                                &extended_tcode);
 565
 566         KUNIT_EXPECT_EQ(test, 0xffc0, dst_id);
 567         KUNIT_EXPECT_EQ(test, 0x0b, tlabel);
 568         KUNIT_EXPECT_EQ(test, 0x01, retry);
 569         KUNIT_EXPECT_EQ(test, TCODE_LOCK_REQUEST, tcode);
 570         KUNIT_EXPECT_EQ(test, 0x00, priority);
 571         KUNIT_EXPECT_EQ(test, 0xffc1, src_id);
 572         KUNIT_EXPECT_EQ(test, 0xfffff0000984, offset);
 573         KUNIT_EXPECT_EQ(test, 0x0008, data_length);
 574         KUNIT_EXPECT_EQ(test, EXTCODE_COMPARE_SWAP, extended_tcode);
 575
 576         serialize_async_header_block_request(header, dst_id, tlabel, retry, tcode, priority, src_id,
 577                                              offset, data_length, extended_tcode);
 578
 579         KUNIT_EXPECT_MEMEQ(test, header, expected, sizeof(expected));
 580 }
 581
 582 static void test_async_header_lock_response(struct kunit *test)
 583 {
 584         static const u32 expected[ASYNC_HEADER_QUADLET_COUNT] = {
 585                 0xffc12db0,
 586                 0xffc00000,
 587                 0x00000000,
 588                 0x00040002,
 589         };
 590         u32 header[ASYNC_HEADER_QUADLET_COUNT] = {0, 0, 0, 0};
 591
 592         unsigned int dst_id;
 593         unsigned int tlabel;
 594         unsigned int retry;
 595         unsigned int tcode;
 596         unsigned int priority;
 597         unsigned int src_id;
 598         unsigned int rcode;
 599         unsigned int data_length;
 600         unsigned int extended_tcode;
 601
 602         deserialize_async_header_block_response(expected, &dst_id, &tlabel, &retry, &tcode,
 603                                                 &priority, &src_id, &rcode, &data_length,
 604                                                 &extended_tcode);
 605
 606         KUNIT_EXPECT_EQ(test, 0xffc1, dst_id);
 607         KUNIT_EXPECT_EQ(test, 0x0b, tlabel);
 608         KUNIT_EXPECT_EQ(test, 0x01, retry);
 609         KUNIT_EXPECT_EQ(test, TCODE_LOCK_RESPONSE, tcode);
 610         KUNIT_EXPECT_EQ(test, 0x00, priority);
 611         KUNIT_EXPECT_EQ(test, 0xffc0, src_id);
 612         KUNIT_EXPECT_EQ(test, RCODE_COMPLETE, rcode);
 613         KUNIT_EXPECT_EQ(test, 0x0004, data_length);
 614         KUNIT_EXPECT_EQ(test, EXTCODE_COMPARE_SWAP, extended_tcode);
 615
 616         serialize_async_header_block_response(header, dst_id, tlabel, retry, tcode, priority,
 617                                               src_id, rcode, data_length, extended_tcode);
 618
 619         KUNIT_EXPECT_MEMEQ(test, header, expected, sizeof(expected));
 620 }
 621
 622 static void test_isoc_header(struct kunit *test)
 623 {
 624         const u32 expected = 0x00d08dec;
 625         u32 header = 0;
 626
 627         unsigned int data_length;
 628         unsigned int tag;
 629         unsigned int channel;
 630         unsigned int tcode;
 631         unsigned int sy;
 632
 633         deserialize_isoc_header(expected, &data_length, &tag, &channel, &tcode, &sy);
 634
 635         KUNIT_EXPECT_EQ(test, 0xd0, data_length);
 636         KUNIT_EXPECT_EQ(test, 0x02, tag);
 637         KUNIT_EXPECT_EQ(test, 0x0d, channel);
 638         KUNIT_EXPECT_EQ(test, 0x0e, tcode);
 639         KUNIT_EXPECT_EQ(test, 0x0c, sy);
 640
 641         serialize_isoc_header(&header, data_length, tag, channel, tcode, sy);
 642
 643         KUNIT_EXPECT_EQ(test, header, expected);
 644 }
 645
 646 static void test_phy_packet_self_id_zero_case0(struct kunit *test)
 647 {
 648         // TSB41AB1/2 with 1 port.
 649         const u32 expected[] = {0x80458c80};
 650         u32 quadlets[] = {0};
 651
 652         unsigned int packet_identifier;
 653         unsigned int phy_id;
 654         bool extended;
 655         bool link_is_active;
 656         unsigned int gap_count;
 657         unsigned int scode;
 658         bool is_contender;
 659         unsigned int power_class;
 660         enum phy_packet_self_id_port_status port_status[3];
 661         bool is_initiated_reset;
 662         bool has_more_packets;
 663         unsigned int port_index;
 664
 665         deserialize_phy_packet_self_id_zero(expected[0], &packet_identifier, &phy_id, &extended,
 666                                             &link_is_active, &gap_count, &scode, &is_contender,
 667                                             &power_class, &is_initiated_reset, &has_more_packets);
 668
 669         KUNIT_EXPECT_EQ(test, PHY_PACKET_PACKET_IDENTIFIER_SELF_ID, packet_identifier);
 670         KUNIT_EXPECT_EQ(test, 0, phy_id);
 671         KUNIT_EXPECT_FALSE(test, extended);
 672         KUNIT_EXPECT_TRUE(test, link_is_active);
 673         KUNIT_EXPECT_EQ(test, 0x05, gap_count);
 674         KUNIT_EXPECT_EQ(test, SCODE_400, scode);
 675         KUNIT_EXPECT_TRUE(test, is_contender);
 676         KUNIT_EXPECT_EQ(test, 0x4, power_class);
 677         KUNIT_EXPECT_FALSE(test, is_initiated_reset);
 678         KUNIT_EXPECT_FALSE(test, has_more_packets);
 679
 680         serialize_phy_packet_self_id_zero(quadlets, packet_identifier, phy_id, extended,
 681                                           link_is_active, gap_count, scode, is_contender,
 682                                           power_class, is_initiated_reset, has_more_packets);
 683
 684         for (port_index = 0; port_index < ARRAY_SIZE(port_status); ++port_index) {
 685                 port_status[port_index] =
 686                         self_id_sequence_get_port_status(expected, ARRAY_SIZE(expected), port_index);
 687         }
 688
 689         KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_PARENT, port_status[0]);
 690         KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NONE, port_status[1]);
 691         KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NONE, port_status[2]);
 692
 693         for (port_index = 0; port_index < ARRAY_SIZE(port_status); ++port_index) {
 694                 self_id_sequence_set_port_status(quadlets, ARRAY_SIZE(quadlets), port_index,
 695                                                  port_status[port_index]);
 696         }
 697
 698         KUNIT_EXPECT_MEMEQ(test, quadlets, expected, sizeof(expected));
 699 }
 700
 701 static void test_phy_packet_self_id_zero_case1(struct kunit *test)
 702 {
 703         // XIO2213 and TSB81BA3E with 3 ports.
 704         const u32 expected[] = {0x817fcc5e};
 705         u32 quadlets[] = {0};
 706
 707         unsigned int packet_identifier;
 708         unsigned int phy_id;
 709         bool extended;
 710         bool link_is_active;
 711         unsigned int gap_count;
 712         unsigned int scode;
 713         bool is_contender;
 714         unsigned int power_class;
 715         enum phy_packet_self_id_port_status port_status[3];
 716         bool is_initiated_reset;
 717         bool has_more_packets;
 718         unsigned int port_index;
 719
 720         deserialize_phy_packet_self_id_zero(expected[0], &packet_identifier, &phy_id, &extended,
 721                                             &link_is_active, &gap_count, &scode, &is_contender,
 722                                             &power_class, &is_initiated_reset, &has_more_packets);
 723
 724         KUNIT_EXPECT_EQ(test, PHY_PACKET_PACKET_IDENTIFIER_SELF_ID, packet_identifier);
 725         KUNIT_EXPECT_EQ(test, 1, phy_id);
 726         KUNIT_EXPECT_FALSE(test, extended);
 727         KUNIT_EXPECT_TRUE(test, link_is_active);
 728         KUNIT_EXPECT_EQ(test, 0x3f, gap_count);
 729         KUNIT_EXPECT_EQ(test, SCODE_800, scode);
 730         KUNIT_EXPECT_TRUE(test, is_contender);
 731         KUNIT_EXPECT_EQ(test, 0x4, power_class);
 732         KUNIT_EXPECT_TRUE(test, is_initiated_reset);
 733         KUNIT_EXPECT_FALSE(test, has_more_packets);
 734
 735         serialize_phy_packet_self_id_zero(quadlets, packet_identifier, phy_id, extended,
 736                                           link_is_active, gap_count, scode, is_contender,
 737                                           power_class, is_initiated_reset, has_more_packets);
 738
 739         for (port_index = 0; port_index < ARRAY_SIZE(port_status); ++port_index) {
 740                 port_status[port_index] =
 741                         self_id_sequence_get_port_status(expected, ARRAY_SIZE(expected), port_index);
 742         }
 743
 744         KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NCONN, port_status[0]);
 745         KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NCONN, port_status[1]);
 746         KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_CHILD, port_status[2]);
 747
 748         for (port_index = 0; port_index < ARRAY_SIZE(port_status); ++port_index) {
 749                 self_id_sequence_set_port_status(quadlets, ARRAY_SIZE(quadlets), port_index,
 750                                                  port_status[port_index]);
 751         }
 752
 753         KUNIT_EXPECT_MEMEQ(test, quadlets, expected, sizeof(expected));
 754 }
 755
 756 static void test_phy_packet_self_id_zero_and_one(struct kunit *test)
 757 {
 758         // TSB41LV06A with 6 ports.
 759         const u32 expected[] = {
 760                 0x803f8459,
 761                 0x80815000,
 762         };
 763         u32 quadlets[] = {0, 0};
 764
 765         unsigned int packet_identifier;
 766         unsigned int phy_id;
 767         bool extended;
 768         bool link_is_active;
 769         unsigned int gap_count;
 770         unsigned int scode;
 771         bool is_contender;
 772         unsigned int power_class;
 773         enum phy_packet_self_id_port_status port_status[11];
 774         bool is_initiated_reset;
 775         bool has_more_packets;
 776
 777         unsigned int sequence;
 778         unsigned int port_index;
 779
 780         deserialize_phy_packet_self_id_zero(expected[0], &packet_identifier, &phy_id, &extended,
 781                                             &link_is_active, &gap_count, &scode, &is_contender,
 782                                             &power_class, &is_initiated_reset, &has_more_packets);
 783
 784         KUNIT_EXPECT_EQ(test, PHY_PACKET_PACKET_IDENTIFIER_SELF_ID, packet_identifier);
 785         KUNIT_EXPECT_EQ(test, 0, phy_id);
 786         KUNIT_EXPECT_FALSE(test, extended);
 787         KUNIT_EXPECT_FALSE(test, link_is_active);
 788         KUNIT_EXPECT_EQ(test, 0x3f, gap_count);
 789         KUNIT_EXPECT_EQ(test, SCODE_400, scode);
 790         KUNIT_EXPECT_FALSE(test, is_contender);
 791         KUNIT_EXPECT_EQ(test, 0x4, power_class);
 792         KUNIT_EXPECT_FALSE(test, is_initiated_reset);
 793         KUNIT_EXPECT_TRUE(test, has_more_packets);
 794
 795         serialize_phy_packet_self_id_zero(quadlets, packet_identifier, phy_id, extended,
 796                                           link_is_active, gap_count, scode, is_contender,
 797                                           power_class, is_initiated_reset, has_more_packets);
 798
 799         deserialize_phy_packet_self_id_extended(expected[1], &packet_identifier, &phy_id, &extended,
 800                                                 &sequence, &has_more_packets);
 801
 802         KUNIT_EXPECT_EQ(test, PHY_PACKET_PACKET_IDENTIFIER_SELF_ID, packet_identifier);
 803         KUNIT_EXPECT_EQ(test, 0, phy_id);
 804         KUNIT_EXPECT_TRUE(test, extended);
 805         KUNIT_EXPECT_EQ(test, 0, sequence);
 806         KUNIT_EXPECT_FALSE(test, has_more_packets);
 807
 808         serialize_phy_packet_self_id_extended(&quadlets[1], packet_identifier, phy_id, extended,
 809                                               sequence, has_more_packets);
 810
 811
 812         for (port_index = 0; port_index < ARRAY_SIZE(port_status); ++port_index) {
 813                 port_status[port_index] =
 814                         self_id_sequence_get_port_status(expected, ARRAY_SIZE(expected), port_index);
 815         }
 816
 817         KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NCONN, port_status[0]);
 818         KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NCONN, port_status[1]);
 819         KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_PARENT, port_status[2]);
 820         KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NCONN, port_status[3]);
 821         KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NCONN, port_status[4]);
 822         KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NCONN, port_status[5]);
 823         KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NONE, port_status[6]);
 824         KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NONE, port_status[7]);
 825         KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NONE, port_status[8]);
 826         KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NONE, port_status[9]);
 827         KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NONE, port_status[10]);
 828
 829         for (port_index = 0; port_index < ARRAY_SIZE(port_status); ++port_index) {
 830                 self_id_sequence_set_port_status(quadlets, ARRAY_SIZE(quadlets), port_index,
 831                                                  port_status[port_index]);
 832         }
 833
 834         KUNIT_EXPECT_MEMEQ(test, quadlets, expected, sizeof(expected));
 835 }
 836
 837 static void test_phy_packet_phy_config_force_root_node(struct kunit *test)
 838 {
 839         const u32 expected = 0x02800000;
 840         u32 quadlet = 0;
 841
 842         unsigned int packet_identifier;
 843         unsigned int root_id;
 844         bool has_force_root_node;
 845         bool has_gap_count_optimization;
 846         unsigned int gap_count;
 847
 848         deserialize_phy_packet_phy_config(expected, &packet_identifier, &root_id,
 849                                           &has_force_root_node, &has_gap_count_optimization,
 850                                           &gap_count);
 851
 852         KUNIT_EXPECT_EQ(test, PHY_PACKET_PACKET_IDENTIFIER_PHY_CONFIG, packet_identifier);
 853         KUNIT_EXPECT_EQ(test, 0x02, root_id);
 854         KUNIT_EXPECT_TRUE(test, has_force_root_node);
 855         KUNIT_EXPECT_FALSE(test, has_gap_count_optimization);
 856         KUNIT_EXPECT_EQ(test, 0, gap_count);
 857
 858         serialize_phy_packet_phy_config(&quadlet, packet_identifier, root_id, has_force_root_node,
 859                                         has_gap_count_optimization, gap_count);
 860
 861         KUNIT_EXPECT_EQ(test, quadlet, expected);
 862 }
 863
 864 static void test_phy_packet_phy_config_gap_count_optimization(struct kunit *test)
 865 {
 866         const u32 expected = 0x034f0000;
 867         u32 quadlet = 0;
 868
 869         unsigned int packet_identifier;
 870         unsigned int root_id;
 871         bool has_force_root_node;
 872         bool has_gap_count_optimization;
 873         unsigned int gap_count;
 874
 875         deserialize_phy_packet_phy_config(expected, &packet_identifier, &root_id,
 876                                           &has_force_root_node, &has_gap_count_optimization,
 877                                           &gap_count);
 878
 879         KUNIT_EXPECT_EQ(test, PHY_PACKET_PACKET_IDENTIFIER_PHY_CONFIG, packet_identifier);
 880         KUNIT_EXPECT_EQ(test, 0x03, root_id);
 881         KUNIT_EXPECT_FALSE(test, has_force_root_node);
 882         KUNIT_EXPECT_TRUE(test, has_gap_count_optimization);
 883         KUNIT_EXPECT_EQ(test, 0x0f, gap_count);
 884
 885         serialize_phy_packet_phy_config(&quadlet, packet_identifier, root_id, has_force_root_node,
 886                                         has_gap_count_optimization, gap_count);
 887
 888         KUNIT_EXPECT_EQ(test, quadlet, expected);
 889 }
 890
 891 static struct kunit_case packet_serdes_test_cases[] = {
 892         KUNIT_CASE(test_async_header_write_quadlet_request),
 893         KUNIT_CASE(test_async_header_write_block_request),
 894         KUNIT_CASE(test_async_header_write_response),
 895         KUNIT_CASE(test_async_header_read_quadlet_request),
 896         KUNIT_CASE(test_async_header_read_quadlet_response),
 897         KUNIT_CASE(test_async_header_read_block_request),
 898         KUNIT_CASE(test_async_header_read_block_response),
 899         KUNIT_CASE(test_async_header_lock_request),
 900         KUNIT_CASE(test_async_header_lock_response),
 901         KUNIT_CASE(test_isoc_header),
 902         KUNIT_CASE(test_phy_packet_self_id_zero_case0),
 903         KUNIT_CASE(test_phy_packet_self_id_zero_case1),
 904         KUNIT_CASE(test_phy_packet_self_id_zero_and_one),
 905         KUNIT_CASE(test_phy_packet_phy_config_force_root_node),
 906         KUNIT_CASE(test_phy_packet_phy_config_gap_count_optimization),
 907         {}
 908 };
 909
 910 static struct kunit_suite packet_serdes_test_suite = {
 911         .name = "firewire-packet-serdes",
 912         .test_cases = packet_serdes_test_cases,
 913 };
 914 kunit_test_suite(packet_serdes_test_suite);
 915
 916 MODULE_DESCRIPTION("FireWire packet serialization/deserialization unit test suite");
 917 MODULE_LICENSE("GPL");