@@ -418,6 +418,7 @@ pub const I2c = struct {
418
418
region_req_size : usize ,
419
419
region_resp_size : usize ,
420
420
region_data_size : usize ,
421
+ region_meta_size : usize ,
421
422
driver_config : ConfigResources.I2c.Driver ,
422
423
virt_config : ConfigResources.I2c.Virt ,
423
424
client_configs : std .ArrayList (ConfigResources .I2c .Client ),
@@ -431,6 +432,7 @@ pub const I2c = struct {
431
432
region_req_size : usize = 0x1000 ,
432
433
region_resp_size : usize = 0x1000 ,
433
434
region_data_size : usize = 0x1000 ,
435
+ region_meta_size : usize = 0x10000 ,
434
436
};
435
437
436
438
pub fn init (allocator : Allocator , sdf : * SystemDescription , device : ? * dtb.Node , driver : * Pd , virt : * Pd , options : Options ) I2c {
@@ -445,11 +447,11 @@ pub const I2c = struct {
445
447
.region_req_size = options .region_req_size ,
446
448
.region_resp_size = options .region_resp_size ,
447
449
.region_data_size = options .region_data_size ,
450
+ .region_meta_size = options .region_meta_size ,
448
451
.driver_config = std .mem .zeroInit (ConfigResources .I2c .Driver , .{}),
449
452
.virt_config = std .mem .zeroInit (ConfigResources .I2c .Virt , .{}),
450
453
.client_configs = std .ArrayList (ConfigResources .I2c .Client ).init (allocator ),
451
- // TODO: handle properly
452
- .num_buffers = 128 ,
454
+ .num_buffers = 64 ,
453
455
};
454
456
}
455
457
@@ -505,18 +507,15 @@ pub const I2c = struct {
505
507
506
508
system .driver_config = .{
507
509
.virt = .{
508
- // Will be set in connectClient
509
- .data = undefined ,
510
510
.req_queue = .createFromMap (driver_map_req ),
511
511
.resp_queue = .createFromMap (driver_map_resp ),
512
512
.num_buffers = system .num_buffers ,
513
513
.id = ch .pd_a_id ,
514
514
},
515
+ .meta_size = system .region_meta_size ,
515
516
};
516
517
517
518
system .virt_config .driver = .{
518
- // Will be set in connectClient
519
- .data = undefined ,
520
519
.req_queue = .createFromMap (virt_map_req ),
521
520
.resp_queue = .createFromMap (virt_map_resp ),
522
521
.num_buffers = system .num_buffers ,
@@ -535,14 +534,20 @@ pub const I2c = struct {
535
534
const mr_req = Mr .create (allocator , fmt (allocator , "i2c_client_request_{s}" , .{client .name }), system .region_req_size , .{});
536
535
const mr_resp = Mr .create (allocator , fmt (allocator , "i2c_client_response_{s}" , .{client .name }), system .region_resp_size , .{});
537
536
const mr_data = Mr .create (allocator , fmt (allocator , "i2c_client_data_{s}" , .{client .name }), system .region_data_size , .{});
537
+ const mr_meta = Mr .create (allocator , fmt (allocator , "i2c_client_meta_{s}" , .{client .name }), system .region_meta_size , .{});
538
538
539
539
sdf .addMemoryRegion (mr_req );
540
540
sdf .addMemoryRegion (mr_resp );
541
541
sdf .addMemoryRegion (mr_data );
542
+ sdf .addMemoryRegion (mr_meta );
542
543
543
544
const driver_map_data = Map .create (mr_data , system .driver .getMapVaddr (& mr_data ), .rw , .{});
544
545
driver .addMap (driver_map_data );
545
546
547
+ // The meta region backs buffers in the data region. Accessed only by driver and client.
548
+ const driver_map_meta = Map .create (mr_meta , system .driver .getMapVaddr (& mr_meta ), .rw , .{ .cached = false });
549
+ driver .addMap (driver_map_meta );
550
+
546
551
const virt_map_req = Map .create (mr_req , system .virt .getMapVaddr (& mr_req ), .rw , .{});
547
552
virt .addMap (virt_map_req );
548
553
const virt_map_resp = Map .create (mr_resp , system .virt .getMapVaddr (& mr_resp ), .rw , .{});
@@ -552,38 +557,46 @@ pub const I2c = struct {
552
557
client .addMap (client_map_req );
553
558
const client_map_resp = Map .create (mr_resp , client .getMapVaddr (& mr_resp ), .rw , .{});
554
559
client .addMap (client_map_resp );
560
+
555
561
const client_map_data = Map .create (mr_data , client .getMapVaddr (& mr_data ), .rw , .{});
556
562
client .addMap (client_map_data );
563
+ const client_map_meta = Map .create (mr_meta , client .getMapVaddr (& mr_meta ), .rw , .{ .cached = false });
564
+ client .addMap (client_map_meta );
557
565
558
566
// Create a channel between the virtualiser and client
559
567
const ch = Channel .create (virt , client , .{ .pp = .b }) catch unreachable ;
560
568
sdf .addChannel (ch );
561
569
570
+ // The below section originally passed the virt a region structure with no vaddr for the
571
+ // data region. Instead of doing this, just pass the size of the region.
562
572
system .virt_config .clients [i ] = .{
563
573
.conn = .{
564
- .data = .{
565
- // TODO: absolute hack
566
- .vaddr = 0 ,
567
- .size = system .region_data_size ,
568
- },
569
574
.req_queue = .createFromMap (virt_map_req ),
570
575
.resp_queue = .createFromMap (virt_map_resp ),
571
576
.num_buffers = system .num_buffers ,
572
577
.id = ch .pd_a_id ,
573
578
},
574
- .driver_data_offset = i * system .region_data_size ,
579
+ .data_size = system .region_data_size ,
580
+ .meta_size = system .region_meta_size ,
581
+ // vaddrs used to convert offsets in cmd / meta buffers to a pointer used by the driver
582
+ // .driver_data_vaddr = i * driver_map_data.vaddr,
583
+ // .driver_meta_vaddr = i * driver_map_meta.vaddr,
584
+ .driver_data_vaddr = driver_map_data .vaddr ,
585
+ .driver_meta_vaddr = driver_map_meta .vaddr ,
586
+ .client_data_vaddr = client_map_data .vaddr ,
587
+ .client_meta_vaddr = client_map_meta .vaddr ,
575
588
};
576
- if (i == 0 ) {
577
- system .driver_config .virt .data = .createFromMap (driver_map_data );
578
- }
579
589
580
- system .client_configs .items [i ] = .{ .virt = .{
590
+ system .client_configs .items [i ] = .{
591
+ .virt = .{
592
+ .req_queue = .createFromMap (client_map_req ),
593
+ .resp_queue = .createFromMap (client_map_resp ),
594
+ .num_buffers = system .num_buffers ,
595
+ .id = ch .pd_b_id ,
596
+ },
581
597
.data = .createFromMap (client_map_data ),
582
- .req_queue = .createFromMap (client_map_req ),
583
- .resp_queue = .createFromMap (client_map_resp ),
584
- .num_buffers = system .num_buffers ,
585
- .id = ch .pd_b_id ,
586
- } };
598
+ .meta = .createFromMap (client_map_meta ),
599
+ };
587
600
}
588
601
589
602
pub fn connect (system : * I2c ) ! void {
@@ -596,7 +609,7 @@ pub const I2c = struct {
596
609
// 2. Connect the driver to the virtualiser
597
610
system .connectDriver ();
598
611
599
- // 3. Connect each client to the virtualiser
612
+ // 3. Connect each client to the virtualiser (and connect the meta region to the driver)
600
613
for (system .clients .items , 0.. ) | client , i | {
601
614
system .connectClient (client , i );
602
615
}
0 commit comments