code cleanup

ip/sc_config/inc/sc_config_regs.h

@@ -111,7 +111,8 @@ typedef union {
         uint8_t shmask_enable:1;
         uint8_t shmask_iv_x:4;
         uint8_t shmask_iv_y:4;
-        uint32_t misc_rsv:8;
+        uint8_t panasonic_hack:1;
+        uint32_t misc_rsv:7;
     } __attribute__((packed, __may_alias__));
     uint32_t data;
 } misc_config_reg;
@@ -152,8 +153,7 @@ typedef struct {
 
 // lumacode palatte ram
 typedef struct {
-    uint32_t padding[16];
+    uint32_t data[512];
-    uint32_t data[496];
 } lc_pal_ram;
 
 typedef struct {

rtl/scanconverter.v

@@ -161,6 +161,7 @@ wire MISC_BFI_ENABLE = 1'b0;
 wire MISC_SHMASK_ENABLE = misc_config[15];
 wire [3:0] MISC_SHMASK_IV_X = misc_config[19:16];
 wire [3:0] MISC_SHMASK_IV_Y = misc_config[23:20];
+wire MISC_PANASONIC_HACK = misc_config[24];
 
 wire [7:0] MASK_R = MISC_MASK_COLOR[2] ? {2{MISC_MASK_BR}} : 8'h00;
 wire [7:0] MASK_G = MISC_MASK_COLOR[1] ? {2{MISC_MASK_BR}} : 8'h00;
@@ -180,6 +181,7 @@ reg [11:0] h_cnt;
 reg [10:0] v_cnt;
 reg h_avidstart, v_avidstart;
 reg src_fid, dst_fid;
+wire [6:0] panasonic_adjust = (MISC_PANASONIC_HACK & (Y_RPT == 4'h1) & (v_cnt == V_SYNCLEN+V_BACKPORCH+V_ACTIVE-1)) ? 8'd128 : 7'd0;
 
 reg [10:0] xpos_lb;
 wire [10:0] xpos_lb_start = (X_OFFSET < 10'sd0) ? 11'd0 : {1'b0, X_OFFSET};
@@ -443,7 +445,7 @@ always @(posedge PCLK_OUT_i) begin
         VSYNC_pp[1] <= ((v_cnt < V_SYNCLEN) | ((v_cnt == V_TOTAL) & (h_cnt >= (H_TOTAL/2)))) ? 1'b0 : 1'b1;
     else
         VSYNC_pp[1] <= ((v_cnt < V_SYNCLEN-1) | ((v_cnt == V_SYNCLEN-1) & (h_cnt < (H_TOTAL/2)))) ? 1'b0 : 1'b1;
-    DE_pp[1] <= (h_cnt >= H_SYNCLEN+H_BACKPORCH) & (h_cnt < H_SYNCLEN+H_BACKPORCH+H_ACTIVE) & (v_cnt >= V_SYNCLEN+V_BACKPORCH) & (v_cnt < V_SYNCLEN+V_BACKPORCH+V_ACTIVE);
+    DE_pp[1] <= (h_cnt >= H_SYNCLEN+H_BACKPORCH) & (h_cnt < H_SYNCLEN+H_BACKPORCH+H_ACTIVE-panasonic_adjust) & (v_cnt >= V_SYNCLEN+V_BACKPORCH) & (v_cnt < V_SYNCLEN+V_BACKPORCH+V_ACTIVE);
 
     if (h_avidstart) begin
         // Start 1 line before active so that linebuffer can be filled from DRAM in time

rtl/tvp7002_frontend.v

@@ -64,6 +64,15 @@ localparam FID_ODD = 1'b1;
 localparam VSYNC_SEPARATED = 1'b0;
 localparam VSYNC_RAW = 1'b1;
 
+localparam LC_DISABLED = 3'd0;
+localparam LC_C64      = 3'd1;
+localparam LC_SPECTRUM = 3'd2;
+localparam LC_MSX      = 3'd3;
+localparam LC_INTV     = 3'd4;
+localparam LC_NES      = 3'd5;
+localparam LC_GTIA     = 3'd6;
+localparam LC_CTIA     = 3'd7;
+
 localparam PP_PL_START      = 1;
 localparam PP_DE_POS_START  = PP_PL_START;
 localparam PP_DE_POS_LENGTH = 1;
@@ -150,8 +159,8 @@ wire HSYNC_i_np = (HSYNC_i ^ ~hsync_i_pol);
 wire [3:0] H_SKIP = hv_in_config3[27:24];
 wire [3:0] H_SAMPLE_SEL = hv_in_config3[31:28];
 
-// Lumacode uses 2 samples for {C64, C128, VIC20, Spectrum, TMS99xxA}, 3 samples for NES, 6 samples for Atari 8bit (3 per pixel) and 4 samples for VCS (2 per half-pixel)
+// Lumacode
-wire [2:0] LC_SAMPLES = (MISC_LUMACODE_MODE <= 3) ? 2 : ((MISC_LUMACODE_MODE <= 5) ? 3 : 2);
+wire [2:0] LC_SAMPLES;
 wire [2:0] LC_H_SKIP = ((H_SKIP+1) / LC_SAMPLES) - 1;
 
 // SOF position for scaler
@@ -168,6 +177,15 @@ function [7:0] apply_reverse_lpf;
     end
 endfunction
 
+// Lumacode number of samples selection
+always @(*) begin
+    case(MISC_LUMACODE_MODE)
+      LC_C64,LC_SPECTRUM,LC_MSX,LC_CTIA : LC_SAMPLES = 2; // 2 samples for {C64, C128, VIC20, Spectrum, TMS99xxA} / 4 samples for VCS (2 per half-pixel)
+      LC_INTV                           : LC_SAMPLES = 1; // 2 samples for Intellivision (1 per doubled pixel)
+      LC_NES,LC_GTIA                    : LC_SAMPLES = 3; // 3 samples for NES / 6 samples for Atari 8bit (3 per pixel)
+      default                           : LC_SAMPLES = 1;
+    endcase
+end
 
 // Pipeline stage 1
 always @(posedge PCLK_i) begin
@@ -264,11 +282,16 @@ always @(posedge PCLK_i) begin
 
     // Lumacode related source-specific registers (used as part of palette RAM addressing / data processing)
     // Lumacode NES
-    if (MISC_LUMACODE_MODE == 4) begin
+    if (MISC_LUMACODE_MODE == LC_NES) begin
         if ((h_ctr == H_SAMPLE_SEL) & ({lc_code[1], lc_code[2], lc_code[3]} < 8))
             lc_emp_nes <= {lc_code[2][0], lc_code[3]};
+    // Lumacode Intellivision
+    end else if (MISC_LUMACODE_MODE == LC_INTV) begin
+        if ((h_ctr == H_SAMPLE_SEL) & lc_atari_ctr) begin
+            lc_atari_luma[1:0] <= lc_code[1];
+        end
     // Lumacode Atari GTIA
-    end else if (MISC_LUMACODE_MODE == 5) begin
+    end else if (MISC_LUMACODE_MODE == LC_GTIA) begin
         if (h_ctr == H_SAMPLE_SEL) begin
             if (lc_atari_ctr) begin
                 // Store hue and luma (high bits) for 1st pixel, and display last pixel of previous pair
@@ -344,15 +367,15 @@ always @(posedge PCLK_i) begin
     B_diff_s15 <= (B_diff_s15_pre * MISC_REV_LPF_STR);
 
     // Cycle 3
-    if (MISC_REV_LPF_ENABLE & (MISC_LUMACODE_MODE == 0)) begin
+    if (MISC_REV_LPF_ENABLE & (MISC_LUMACODE_MODE == LC_DISABLED)) begin
         R_pp[PP_RLPF_END] <= apply_reverse_lpf(R_pp[PP_RLPF_START+2], R_diff_s15);
         G_pp[PP_RLPF_END] <= apply_reverse_lpf(G_pp[PP_RLPF_START+2], G_diff_s15);
         B_pp[PP_RLPF_END] <= apply_reverse_lpf(B_pp[PP_RLPF_START+2], B_diff_s15);
     end
 
     /* --- Lumacode overwrite data from RAM --- */
-    if (MISC_LUMACODE_MODE != 0) begin
+    if (MISC_LUMACODE_MODE != LC_DISABLED) begin
-        if (MISC_LUMACODE_MODE == 4) begin
+        if (MISC_LUMACODE_MODE == LC_NES) begin
             // NES
             R_pp[PP_RLPF_START+1] <= &lc_emp_nes[1:0] ? (lumacode_data[23:16]/2) : (|lc_emp_nes[1:0] ? (lumacode_data[23:16] - lumacode_data[23:16]/4) : lumacode_data[23:16]);
             G_pp[PP_RLPF_START+1] <= (lc_emp_nes[2] & lc_emp_nes[0]) ? (lumacode_data[15:8]/2) : ((lc_emp_nes[2] | lc_emp_nes[0]) ? (lumacode_data[15:8] - lumacode_data[15:8]/4) : lumacode_data[15:8]);
@@ -369,30 +392,34 @@ end
 // Lumacode palette RAM inputs
 always @(*)
 case (MISC_LUMACODE_MODE)
-    1: begin // C64, C128, VIC20
+    LC_C64: begin // C64, C128, VIC20
+        lumacode_addr = {5'h0, lc_code[1], lc_code[2]};
+        lumacode_rden = 1;
+    end
+    LC_SPECTRUM: begin // Spectrum
         lumacode_addr = {5'h1, lc_code[1], lc_code[2]};
         lumacode_rden = 1;
     end
-    2: begin // Spectrum
+    LC_MSX: begin // TMS99xxA
         lumacode_addr = {5'h2, lc_code[1], lc_code[2]};
         lumacode_rden = 1;
     end
-    3: begin // TMS99xxA
+    LC_INTV: begin // Intellivision
-        lumacode_addr = {5'h3, lc_code[1], lc_code[2]};
+        lumacode_addr = {5'h3, lc_atari_luma[1:0], lc_code[1]};
-        lumacode_rden = 1;
+        lumacode_rden = (h_ctr == H_SAMPLE_SEL) & !lc_atari_ctr;
     end
-    4: begin // NES
+    LC_NES: begin // NES
         lumacode_addr = {3'h1, lc_code[1], lc_code[2], lc_code[3]};
         lumacode_rden = 1;
     end
-    6: begin // Atari CTIA/TIA
+    LC_GTIA: begin // Atari GTIA
-        lumacode_addr = {2'h1, lc_atari_hue, lc_code[1], lc_code[2][1]};
-        lumacode_rden = (h_ctr == H_SAMPLE_SEL) & !lc_atari_ctr;
-    end
-    5: begin // Atari GTIA
         lumacode_addr = lc_atari_ctr ? {1'h1, lc_atari_hue, lc_atari_luma} : {1'h1, lc_atari_hue, lc_atari_luma[3:2], lc_code[1]};
         lumacode_rden = (h_ctr == H_SAMPLE_SEL);
     end
+    LC_CTIA: begin // Atari CTIA/TIA
+        lumacode_addr = {2'h1, lc_atari_hue, lc_code[1], lc_code[2][1]};
+        lumacode_rden = (h_ctr == H_SAMPLE_SEL) & !lc_atari_ctr;
+    end
     default: begin // Standard output
         lumacode_addr = '0;
         lumacode_rden = 0;

software/sys_controller/av_controller.c

@@ -143,7 +143,8 @@ int shmask_loaded_array = 0;
 int shmask_loaded_str = -1;
 #define SHMASKS_SIZE  (sizeof(shmask_data_arr_list) / sizeof((shmask_data_arr_list)[0]))
 
-const lc_palette_set* lc_palette_set_list[] = {&lc_palette_pal};
+c_lc_palette_set_t c_lc_palette_set;
+const lc_palette_set* lc_palette_set_list[] = {&lc_palette_pal, &c_lc_palette_set.pal};
 int loaded_lc_palette = -1;
 
 void ui_disp_menu(alt_u8 osd_mode)
@@ -461,11 +462,15 @@ status_t get_status(tvp_sync_input_t syncinput)
     return status;
 }
 
-void update_sc_config(mode_data_t *vm_in, mode_data_t *vm_out, vm_proc_config_t *vm_conf, avconfig_t *avconfig)
+void update_sc_config()
 {
     int i, p, t;
     shmask_data_arr *shmask_data_arr_ptr;
 
+    mode_data_t *vm_in = &vmode_in;
+    mode_data_t *vm_out = &vmode_out;
+    avconfig_t *avconfig = &cm.cc;
+
     hv_config_reg hv_in_config = {.data=0x00000000};
     hv_config2_reg hv_in_config2 = {.data=0x00000000};
     hv_config3_reg hv_in_config3 = {.data=0x00000000};
@@ -511,8 +516,8 @@ void update_sc_config(mode_data_t *vm_in, mode_data_t *vm_out, vm_proc_config_t
     hv_in_config3.v_backporch = vm_in->timings.v_backporch;
     hv_in_config2.interlaced = vm_in->timings.interlaced;
     hv_in_config3.v_startline = vm_in->timings.v_synclen+vm_in->timings.v_backporch+12;
-    hv_in_config3.h_skip = vm_conf->h_skip;
+    hv_in_config3.h_skip = vm_conf.h_skip;
-    hv_in_config3.h_sample_sel = vm_conf->h_sample_sel;
+    hv_in_config3.h_sample_sel = vm_conf.h_sample_sel;
 
     // Set output params
     hv_out_config.h_total = vm_out->timings.h_total;
@@ -524,16 +529,16 @@ void update_sc_config(mode_data_t *vm_in, mode_data_t *vm_out, vm_proc_config_t
     hv_out_config3.v_synclen = vm_out->timings.v_synclen;
     hv_out_config3.v_backporch = vm_out->timings.v_backporch;
     hv_out_config2.interlaced = vm_out->timings.interlaced;
-    hv_out_config3.v_startline = vm_conf->framesync_line;
+    hv_out_config3.v_startline = vm_conf.framesync_line;
 
-    xy_out_config.x_size = vm_conf->x_size;
+    xy_out_config.x_size = vm_conf.x_size;
-    xy_out_config.y_size = vm_conf->y_size;
+    xy_out_config.y_size = vm_conf.y_size;
-    xy_out_config.y_offset = vm_conf->y_offset;
+    xy_out_config.y_offset = vm_conf.y_offset;
-    xy_out_config2.x_offset = vm_conf->x_offset;
+    xy_out_config2.x_offset = vm_conf.x_offset;
-    xy_out_config2.x_start_lb = vm_conf->x_start_lb;
+    xy_out_config2.x_start_lb = vm_conf.x_start_lb;
-    xy_out_config2.y_start_lb = vm_conf->y_start_lb;
+    xy_out_config2.y_start_lb = vm_conf.y_start_lb;
-    xy_out_config2.x_rpt = vm_conf->x_rpt;
+    xy_out_config2.x_rpt = vm_conf.x_rpt;
-    xy_out_config2.y_rpt = vm_conf->y_rpt;
+    xy_out_config2.y_rpt = vm_conf.y_rpt;
 
     misc_config.mask_br = avconfig->mask_br;
     misc_config.mask_color = avconfig->mask_color;
@@ -542,16 +547,13 @@ void update_sc_config(mode_data_t *vm_in, mode_data_t *vm_out, vm_proc_config_t
     misc_config.shmask_iv_x = shmask_data_arr_ptr->iv_x;
     misc_config.shmask_iv_y = shmask_data_arr_ptr->iv_y;
     misc_config.lumacode_mode = avconfig->lumacode_mode;
+    misc_config.panasonic_hack = avconfig->panasonic_hack;
     /*misc_config.lm_deint_mode = 0;
-    misc_config.nir_even_offset = 0;
+    misc_config.nir_even_offset = 0;*/
-    misc_config.ypbpr_cs = (avconfig->ypbpr_cs == 0) ? ((vm_in->type & VIDEO_HDTV) ? 1 : 0) : avconfig->ypbpr_cs-1;
-    misc_config.vip_enable = 0;
-    misc_config.bfi_enable = 0;
-    misc_config.bfi_str = 0;*/
 
     // set default/custom scanline interval
-    sl_def_iv_y = (vm_conf->y_rpt > 0) ? vm_conf->y_rpt : 1;
+    sl_def_iv_y = (vm_conf.y_rpt > 0) ? vm_conf.y_rpt : 1;
-    sl_def_iv_x = (vm_conf->x_rpt > 0) ? vm_conf->x_rpt : sl_def_iv_y;
+    sl_def_iv_x = (vm_conf.x_rpt > 0) ? vm_conf.x_rpt : sl_def_iv_y;
     sl_config3.sl_iv_x = ((avconfig->sl_type == 3) && (avconfig->sl_cust_iv_x)) ? avconfig->sl_cust_iv_x : sl_def_iv_x;
     sl_config3.sl_iv_y = ((avconfig->sl_type == 3) && (avconfig->sl_cust_iv_y)) ? avconfig->sl_cust_iv_y : sl_def_iv_y;
 
@@ -592,7 +594,7 @@ void update_sc_config(mode_data_t *vm_in, mode_data_t *vm_out, vm_proc_config_t
     sl_config3.sl_hybr_str = avconfig->sl_hybr_str;
 
     // disable scanlines if configured so
-    if (((avconfig->sl_mode == 1) && (!vm_conf->y_rpt)) || (avconfig->sl_mode == 0)) {
+    if (((avconfig->sl_mode == 1) && (!vm_conf.y_rpt)) || (avconfig->sl_mode == 0)) {
         sl_config.sl_l_overlay = 0;
         sl_config3.sl_c_overlay = 0;
     }
@@ -710,7 +712,7 @@ void program_mode()
 
     update_osd_size(&vmode_out);
 
-    update_sc_config(&vmode_in, &vmode_out, &vm_conf, &cm.cc);
+    update_sc_config();
 
     TX_SetPixelRepetition(vm_conf.tx_pixelrep, ((cm.cc.tx_mode!=TX_DVI) && (vm_conf.tx_pixelrep == vm_conf.hdmitx_pixr_ifr)) ? 1 : 0);
 
@@ -756,7 +758,7 @@ void set_sampler_phase(uint8_t sampler_phase, uint8_t update_sc) {
     tvp_set_hpll_phase(tvp_phase);
 
     if (update_sc)
-        update_sc_config(&vmode_in, &vmode_out, &vm_conf, &cm.cc);
+        update_sc_config();
 }
 
 int load_profile() {
@@ -802,6 +804,11 @@ void set_default_c_shmask() {
     strncpy(c_shmask.name, "Custom: <none>", 20);
 }
 
+void set_default_c_lc_palette_set() {
+    memset(&c_lc_palette_set, 0, sizeof(c_lc_palette_set));
+    strncpy(c_lc_palette_set.name, "Custom: <none>", 20);
+}
+
 // Initialize hardware
 int init_hw()
 {
@@ -872,6 +879,7 @@ int init_hw()
     // Set defaults
     set_default_profile(1);
     set_default_c_shmask();
+    set_default_c_lc_palette_set();
     set_default_settings();
 
     // Init menu
@@ -886,7 +894,7 @@ int init_hw()
 
     // Setup test pattern
     get_vmode(VMODE_480p, &vmode_in, &vmode_out, &vm_conf);
-    update_sc_config(&vmode_in, &vmode_out, &vm_conf, &cm.cc);
+    update_sc_config();
 
     // init always in HDMI mode (fixes yellow screen bug)
     TX_enable(TX_HDMI_RGB);
@@ -1288,7 +1296,7 @@ int main()
             case SC_CONFIG_CHANGE:
                 if (cm.sync_active) {
                     printf("Scanconverter config change\n");
-                    update_sc_config(&vmode_in, &vmode_out, &vm_conf, &cm.cc);
+                    update_sc_config();
                 }
                 break;
             default:

software/sys_controller/inc/av_controller.h

@@ -119,21 +119,32 @@ typedef union {
         uint32_t c64_pal[16];
         uint32_t zx_pal[16];
         uint32_t msx_pal[16];
+        uint32_t intv_pal[16];
         uint32_t nes_pal[64];
         uint32_t tia_pal[128];
         uint32_t gtia_pal[256];
     } __attribute__((packed, __may_alias__));
-    uint32_t data[496];
+    uint32_t data[512];
 } lc_palette_set;
 
+typedef struct {
+    char name[20];
+    lc_palette_set pal;
+} c_lc_palette_set_t;
+
 void ui_disp_menu(alt_u8 osd_mode);
 void ui_disp_status(alt_u8 refresh_osd_timer);
 
 void set_sampler_phase(uint8_t sampler_phase, uint8_t update_sc);
 
+void set_default_c_shmask();
+void set_default_c_lc_palette_set();
+
 void print_vm_stats();
 int latency_test();
 
+void update_sc_config();
+
 void update_settings(int init_setup);
 
 #endif

software/sys_controller/inc/avconfig.h

@@ -105,6 +105,7 @@ typedef struct {
     alt_u8 tvp_hpll2x;
     alt_u8 adc_pll_bw;
     alt_u8 fpga_pll_bw;
+    alt_u8 panasonic_hack;
 
     /* Postprocessing settings */
     alt_u8 sl_mode;

software/sys_controller/inc/firmware.h

@@ -62,6 +62,6 @@ typedef struct {
 
 int fw_init_secondary();
 int fw_update();
-void fw_update_commit(uint32_t* cluster_idx, uint8_t* databuf, uint32_t bytes_to_copy, uint16_t fs_csize, uint16_t fs_startsec, uint32_t flash_addr);
+void fw_update_commit(uint32_t* cluster_idx, uint32_t bytes_to_copy, uint16_t fs_csize, uint16_t fs_startsec, uint32_t flash_addr);
 
 #endif

software/sys_controller/inc/menu.h

@@ -31,11 +31,22 @@
 #define LNG(e, j) e
 #endif
 
+typedef enum {
+    NO_ACTION    = 0,
+    OPT_SELECT   = RC_OK,
+    PREV_MENU    = RC_BACK,
+    PREV_PAGE    = RC_UP,
+    NEXT_PAGE    = RC_DOWN,
+    VAL_MINUS    = RC_LEFT,
+    VAL_PLUS     = RC_RIGHT,
+} menucode_id; // order must be consequential with rc_code_t
+
 typedef enum {
     OPT_AVCONFIG_SELECTION,
     OPT_AVCONFIG_NUMVALUE,
     OPT_AVCONFIG_NUMVAL_U16,
     OPT_SUBMENU,
+    OPT_CUSTOMMENU,
     OPT_FUNC_CALL,
 } menuitem_type;
 
@@ -43,6 +54,7 @@ typedef int (*func_call)(void);
 typedef void (*arg_func)(void);
 typedef void (*disp_func)(alt_u8);
 typedef void (*disp_func_u16)(alt_u16*);
+typedef void (*cstm_disp_func)(menucode_id, int);
 
 typedef struct {
     alt_u8 *data;
@@ -86,6 +98,10 @@ typedef struct {
     arg_func arg_f;
 } opt_submenu;
 
+typedef struct {
+    cstm_disp_func cstm_f;
+} opt_custommenu;
+
 typedef struct {
     const char *name;
     menuitem_type type;
@@ -94,6 +110,7 @@ typedef struct {
         opt_avconfig_numvalue num;
         opt_avconfig_numvalue_u16 num_u16;
         opt_submenu sub;
+        opt_custommenu cstm;
         opt_func_call fun;
     };
 } menuitem_t;
@@ -107,28 +124,25 @@ struct menustruct {
 #define MENU(X, Y) const menuitem_t X##_items[] = Y; const menu_t X = { sizeof(X##_items)/sizeof(menuitem_t), X##_items };
 #define P99_PROTECT(...) __VA_ARGS__
 
-typedef enum {
-    NO_ACTION    = 0,
-    OPT_SELECT   = RC_OK,
-    PREV_MENU    = RC_BACK,
-    PREV_PAGE    = RC_UP,
-    NEXT_PAGE    = RC_DOWN,
-    VAL_MINUS    = RC_LEFT,
-    VAL_PLUS     = RC_RIGHT,
-} menucode_id; // order must be consequential with rc_code_t
-
 typedef struct {
     const menu_t *m;
     alt_u8 mp;
 } menunavi;
 
+typedef int (*load_func)(char*, char*);
+
 menunavi* get_current_menunavi();
 void init_menu();
 void render_osd_page();
 void display_menu(alt_u8 forcedisp);
 void sampler_phase_disp(alt_u8 v);
+void set_func_ret_msg(char *msg);
 void update_osd_size(mode_data_t *vm_out);
 void refresh_osd();
+void cstm_shmask_load(menucode_id code, int setup_disp);
+void cstm_lc_palette_set_load(menucode_id code, int setup_disp);
+void cstm_fw_update(menucode_id code, int setup_disp);
+void enter_cstm(const menuitem_t *item, int detached_mode);
 static void vm_select();
 static void vm_tweak(alt_u16 *v);
 

software/sys_controller/src/avconfig.c

@@ -77,6 +77,8 @@ int set_default_profile(int update_cc)
     if (update_cc)
         memcpy(&cm.cc, &tc, sizeof(avconfig_t));
 
+    set_default_c_shmask();
+    set_default_c_lc_palette_set();
     set_default_vm_table();
     update_cur_vm = 1;
 

software/sys_controller/src/file.c

@@ -9,6 +9,11 @@ FRESULT file_mount()
     return f_mount(&fs, "", 1);
 }
 
+FRESULT file_unmount()
+{
+    return f_unmount("");
+}
+
 FRESULT file_open(FIL* fil, char* path)
 {
     return f_open(fil, path, FA_READ);

software/sys_controller/src/firmware.c

@@ -40,6 +40,7 @@
 
 extern char menu_row1[LCD_ROW_LEN+1], menu_row2[LCD_ROW_LEN+1];
 extern alt_u16 rc_keymap[REMOTE_MAX_KEYS];
+extern char tmpbuf[SD_BLK_SIZE];
 extern SD_DEV sdcard_dev;
 extern alt_u32 sys_ctrl;
 extern flash_ctrl_dev flashctrl_dev;
@@ -62,8 +63,7 @@ int fw_init_secondary() {
     return 0;
 }
 
-//int fw_update(char *dirname, char *filename) {
+int fw_update(char *dirname, char *filename) {
-int fw_update() {
     FIL fw_file;
     SDRESULTS res;
     char dirname_root[10];
@@ -72,7 +72,6 @@ int fw_update() {
     unsigned bytes_read, bytes_to_copy;
     uint32_t crcval, hdr_len, btn_vec;
     uint32_t cluster_idx[100]; // enough for >=4kB cluster size
-    uint8_t databuf[SD_BLK_SIZE]; // temp buffer for data
     uint16_t fs_csize, fs_startsec, cl_iter, cl_soffs;
     uint32_t flash_addr;
 
@@ -84,11 +83,10 @@ int fw_update() {
         }
     }
 
-    //sniprintf(dirname_root, sizeof(dirname_root), "/%s", dirname);
+    sniprintf(dirname_root, sizeof(dirname_root), "/%s", dirname);
-    sniprintf(dirname_root, sizeof(dirname_root), "/");
     f_chdir(dirname_root);
 
-    if (!file_open(&fw_file, "ossc.bin")) {
+    if (!file_open(&fw_file, filename)) {
         strlcpy(menu_row1, "Checking FW", LCD_ROW_LEN+1);
         strlcpy(menu_row2, "Please wait...", LCD_ROW_LEN+1);
         ui_disp_menu(1);
@@ -140,7 +138,7 @@ int fw_update() {
             if (btn_vec == rc_keymap[RC_BTN1]) {
                 break;
             } else if (btn_vec == rc_keymap[RC_BTN2]) {
-                //set_func_ret_msg("Cancelled");
+                set_func_ret_msg("Cancelled");
                 retval = 1;
                 goto close_file;
             }
@@ -175,14 +173,14 @@ int fw_update() {
         printf("Checking copied data...\n");
         while (bytes_to_copy > 0) {
             bytes_read = (bytes_to_copy > SD_BLK_SIZE) ? SD_BLK_SIZE : bytes_to_copy;
-            res = SD_Read(&sdcard_dev, databuf, ((cluster_idx[cl_iter]-2)*fs_csize+fs_startsec+cl_soffs), 0, bytes_read);
+            res = SD_Read(&sdcard_dev, tmpbuf, ((cluster_idx[cl_iter]-2)*fs_csize+fs_startsec+cl_soffs), 0, bytes_read);
             if (res != SD_OK) {
                 printf("FW data read error\n");
                 retval = -8;
                 goto close_file;
             }
 
-            crcval = crc32((unsigned char *)&databuf, bytes_read, (bytes_to_copy==hdr.data_len));
+            crcval = crc32((unsigned char *)&tmpbuf, bytes_read, (bytes_to_copy==hdr.data_len));
             bytes_to_copy -= bytes_read;
 
             cl_soffs += 1;
@@ -209,7 +207,7 @@ int fw_update() {
         usleep(10000);
 
         // No return from here
-        fw_update_commit(cluster_idx, databuf, hdr.data_len, fs_csize, fs_startsec, flash_addr);
+        fw_update_commit(cluster_idx, hdr.data_len, fs_csize, fs_startsec, flash_addr);
         return 0;
     } else {
         printf("FW file not found\n");
@@ -224,7 +222,7 @@ close_file:
 }
 
 // commit FW update. Do not call functions located in flash during update
-void __attribute__((noinline, flatten, noreturn, __section__(".text_bram"))) fw_update_commit(uint32_t* cluster_idx, uint8_t* databuf, uint32_t bytes_to_copy, uint16_t fs_csize, uint16_t fs_startsec, uint32_t flash_addr) {
+void __attribute__((noinline, flatten, noreturn, __section__(".text_bram"))) fw_update_commit(uint32_t* cluster_idx, uint32_t bytes_to_copy, uint16_t fs_csize, uint16_t fs_startsec, uint32_t flash_addr) {
     int i, sectors;
     SDRESULTS res;
     uint16_t cl_iter, cl_soffs;
@@ -254,14 +252,14 @@ void __attribute__((noinline, flatten, noreturn, __section__(".text_bram"))) fw_
     // Write data
     while (bytes_to_copy > 0) {
         bytes_read = (bytes_to_copy > SD_BLK_SIZE) ? SD_BLK_SIZE : bytes_to_copy;
-        res = SD_Read(&sdcard_dev, databuf, ((cluster_idx[cl_iter]-2)*fs_csize+fs_startsec+cl_soffs), 0, bytes_read);
+        res = SD_Read(&sdcard_dev, tmpbuf, ((cluster_idx[cl_iter]-2)*fs_csize+fs_startsec+cl_soffs), 0, bytes_read);
         //TODO: retry if read fails
 
         bytes_to_copy -= bytes_read;
         for (i=0; i<bytes_read; i++)
-            databuf[i] = bitswap8(databuf[i]);
+            tmpbuf[i] = bitswap8(tmpbuf[i]);
         for (i=0; i<bytes_read; i+=4)
-            *data_to++ = *((uint32_t*)&databuf[i]);
+            *data_to++ = *((uint32_t*)&tmpbuf[i]);
 
         cl_soffs += 1;
         if (cl_soffs == fs_csize) {

software/sys_controller/src/lumacode_palettes.c

@@ -3,6 +3,7 @@
 const lc_palette_set lc_palette_pal = {.c64_pal={0x000000,0x2a1b9d,0x7d202c,0x84258c,0x4c2e00,0x3c3c3c,0x646464,0x4fb3a5,0x7f410d,0x6351db,0x939393,0xbfd04a,0x339840,0xb44f5c,0x7ce587,0xffffff},
                                        .zx_pal= {0x000000,0x000000,0x0200FD,0xCF01CE,0x0100CE,0xCF0100,0xFF02FD,0x01CFCF,0xFF0201,0x00CF15,0x02FFFF,0xFFFF1D,0x00FF1C,0xCFCF15,0xCFCFCF,0xFFFFFF},
                                        .msx_pal={0x000000,0x5455ed,0xfc5554,0xff7978,0x000000,0xd4524d,0x7d76fc,0x42ebf5,0x21b03b,0x21c842,0xff7978,0xcccccc,0xc95bba,0xd4c154,0xe6ce80,0xffffff},
+                                       .intv_pal={0x0c0005,0xa7a8a8,0xfffcff,0xff3e00,0xffa600,0xfaea27,0x00780f,0x00a720,0x6ccd30,0x002dff,0x5acbff,0xbd95ff,0xc81a7d,0xff3276,0x3c5800,0xc9d464},
                                        .nes_pal={0x000000,0x000000,0x000000,0x000000,0x000000,0x000000,0x000000,0x000000,0x626262,0x001fb2,0x2404c8,0x5200b2,0x730076,0x800024,0x730b00,0x522800,
                                                  0x244400,0x005700,0x005c00,0x005324,0x003c76,0x000000,0xababab,0x0d57ff,0x4b30ff,0x8a13ff,0xbc08d6,0xd21269,0xc72e00,0x9d5400,0x607b00,0x209800,
                                                  0x00a300,0x009942,0x007db4,0x000000,0xffffff,0x53aeff,0x9085ff,0xd365ff,0xff57ff,0xff5dcf,0xff7757,0xfa9e00,0xbdc700,0x7ae700,0x43f611,0x26ef7e,

software/sys_controller/src/menu.c

@@ -25,12 +25,16 @@
 #include "userdata.h"
 #include "controls.h"
 #include "lcd.h"
+#include "sdcard.h"
 #include "tvp7002.h"
+#include "ff.h"
+#include "file.h"
 
 #define OPT_NOWRAP  0
 #define OPT_WRAP    1
 
 extern char row1[LCD_ROW_LEN+1], row2[LCD_ROW_LEN+1], menu_row1[LCD_ROW_LEN+1], menu_row2[LCD_ROW_LEN+1];
+char func_ret_status[LCD_ROW_LEN+1];
 extern avmode_t cm;
 extern avconfig_t tc;
 extern settings_t ts;
@@ -44,6 +48,10 @@ extern char target_profile_name[USERDATA_NAME_LEN+1];
 extern volatile osd_regs *osd;
 extern const int num_video_modes_plm;
 extern c_shmask_t c_shmask;
+extern c_lc_palette_set_t c_lc_palette_set;
+extern SD_DEV sdcard_dev;
+extern int shmask_loaded_array;
+extern int loaded_lc_palette;
 
 alt_u16 tc_h_samplerate, tc_h_samplerate_adj, tc_h_synclen, tc_h_bporch, tc_h_active, tc_v_synclen, tc_v_bporch, tc_v_active, tc_sampler_phase, tc_h_mask, tc_v_mask;
 alt_u8 menu_active;
@@ -82,8 +90,8 @@ static const char* const auto_input_desc[] = { "Off", "Current input", "All inpu
 static const char* const mask_color_desc[] = { "Black", "Blue", "Green", "Cyan", "Red", "Magenta", "Yellow", "White" };
 static const char* const av3_alt_rgb_desc[] = { "Off", "AV1", "AV2" };
 static const char* const shmask_mode_desc[] = { "Off", "A-Grille", "TV", "PVM", "PVM-2530", "XC-3315C", "C-1084", "JVC", "VGA", c_shmask.name };
-static const char* const lumacode_mode_desc[] = { "Off", "C64", "Spectrum", "Coleco/MSX", "NES", "Atari GTIA", "Atari VCS" };
+static const char* const lumacode_mode_desc[] = { "Off", "C64", "Spectrum", "Coleco/MSX", "Intellivision", "NES", "Atari GTIA", "Atari VCS" };
-static const char* const lumacode_pal_desc[] = { "PAL" };
+static const char* const lumacode_pal_desc[] = { "PAL", c_lc_palette_set.name };
 static const char* const adc_pll_bw_desc[] = { "High", "Medium", "Low", "Ultra low" };
 static const char* const fpga_pll_bw_desc[] = { "High", "Low" };
 
@@ -164,6 +172,7 @@ MENU(menu_vinputproc, P99_PROTECT({ \
     { "ALC H filter",                           OPT_AVCONFIG_NUMVALUE,  { .num = { &tc.alc_h_filter,  OPT_NOWRAP, 0, ALC_H_FILTER_MAX, alc_h_filter_disp } } },
     { "Lumacode",                              OPT_AVCONFIG_SELECTION, { .sel = { &tc.lumacode_mode,  OPT_WRAP,   SETTING_ITEM(lumacode_mode_desc) } } },
     { "Lc palette set",                        OPT_AVCONFIG_SELECTION, { .sel = { &tc.lumacode_pal,   OPT_WRAP,   SETTING_ITEM(lumacode_pal_desc) } } },
+    { "<Custom Lc-set>",                       OPT_CUSTOMMENU,         { .cstm = { &cstm_lc_palette_set_load } } },
 }))
 
 MENU(menu_sampling, P99_PROTECT({ \
@@ -218,7 +227,7 @@ MENU(menu_scanlines, P99_PROTECT({ \
 
 MENU(menu_postproc, P99_PROTECT({ \
     { "Shadow mask",                             OPT_AVCONFIG_SELECTION, { .sel = { &tc.shmask_mode, OPT_WRAP,   SETTING_ITEM(shmask_mode_desc) } } },
-    //{ "Custom shadow mask",                      OPT_CUSTOMMENU,         { .cstm = { &cstm_shmask_load } } },
+    { "<Custom shmask>",                         OPT_CUSTOMMENU,         { .cstm = { &cstm_shmask_load } } },
     { "Sh. mask strength",                       OPT_AVCONFIG_NUMVALUE,  { .num = { &tc.shmask_str,  OPT_NOWRAP, 0, SCANLINESTR_MAX, sl_str_disp } } },
     { "Border color",                            OPT_AVCONFIG_SELECTION, { .sel = { &tc.mask_color,  OPT_NOWRAP,   SETTING_ITEM(mask_color_desc) } } },
     { LNG("Border brightn.","ﾏｽｸｱｶﾙｻ"),           OPT_AVCONFIG_NUMVALUE,  { .num = { &tc.mask_br,     OPT_NOWRAP, 0, HV_MASK_MAX_BR, value_disp } } },
@@ -231,6 +240,7 @@ MENU(menu_compatibility, P99_PROTECT({ \
     { "AV3 use alt. RGB",                        OPT_AVCONFIG_SELECTION, { .sel = { &tc.av3_alt_rgb,     OPT_WRAP, SETTING_ITEM(av3_alt_rgb_desc) } } },
     { "Full VSYNC bypas",                       OPT_AVCONFIG_SELECTION, { .sel = { &tc.full_vs_bypass,   OPT_WRAP,   SETTING_ITEM(off_on_desc) } } },
     { "Default HDMI VIC",                       OPT_AVCONFIG_NUMVALUE,  { .num = { &tc.default_vic,     OPT_NOWRAP, 0, HDMI_1080p50, value_disp } } },
+    { "Panasonic hack",                        OPT_AVCONFIG_SELECTION, { .sel = { &tc.panasonic_hack,   OPT_WRAP, SETTING_ITEM(off_on_desc) } } },
 }))
 
 MENU(menu_audio, P99_PROTECT({ \
@@ -261,7 +271,7 @@ MENU(menu_settings, P99_PROTECT({ \
     { LNG("<Reset profile>","<ｾｯﾃｲｦｼｮｷｶ    >"),  OPT_FUNC_CALL,          { .fun = { reset_profile, NULL } } },
     //{ LNG("<Import sett.  >","<ｾｯﾃｲﾖﾐｺﾐ      >"), OPT_FUNC_CALL,        { .fun = { import_userdata, NULL } } },
     //{ LNG("<Export sett.  >","<ｾｯﾃｲｶｷｺﾐ      >"), OPT_FUNC_CALL,        { .fun = { export_userdata, NULL } } },
-    { LNG("<Fw. update    >","<ﾌｧｰﾑｳｪｱｱｯﾌﾟﾃﾞｰﾄ>"), OPT_FUNC_CALL,        { .fun = { fw_update, NULL } } },
+    { LNG("<Fw. update    >","<ﾌｧｰﾑｳｪｱｱｯﾌﾟﾃﾞｰﾄ>"), OPT_CUSTOMMENU,         { .cstm = { &cstm_fw_update } } },
     { "<Launch 2nd FW >",                        OPT_FUNC_CALL,        { .fun = { fw_init_secondary, NULL } } },
 }))
 
@@ -282,6 +292,11 @@ MENU(menu_main, P99_PROTECT({ \
 menunavi navi[] = {{&menu_main, 0}, {NULL, 0}, {NULL, 0}};
 alt_u8 navlvl = 0;
 
+static int osd_list_iter;
+char tmpbuf[SD_BLK_SIZE]; // 512 byte temp buffer for data
+
+// Pointer to custom menu display function
+void (*cstm_f)(menucode_id, int);
 
 menunavi* get_current_menunavi() {
     return &navi[navlvl];
@@ -320,12 +335,17 @@ void write_option_value(const menuitem_t *item, int func_called, int retval)
             else
                 menu_row2[0] = 0;
             break;
+        case OPT_CUSTOMMENU:
+            menu_row2[0] = 0;
+            break;
         case OPT_FUNC_CALL:
             if (func_called) {
                 if (retval == 0)
                     strncpy(menu_row2, "Done", LCD_ROW_LEN+1);
                 else if (retval < 0)
                     sniprintf(menu_row2, LCD_ROW_LEN+1, "Failed (%d)", retval);
+                else
+                    strlcpy(menu_row2, func_ret_status, LCD_ROW_LEN+1);
             } else if (item->fun.arg_info) {
                 item->fun.arg_info->df(*item->fun.arg_info->data);
             } else {
@@ -350,7 +370,7 @@ void render_osd_page() {
         strncpy((char*)osd->osd_array.data[i][0], item->name, OSD_CHAR_COLS);
         row_mask[0] |= (1<<i);
 
-        if ((item->type != OPT_SUBMENU) && (item->type != OPT_FUNC_CALL)) {
+        if ((item->type != OPT_SUBMENU) && (item->type != OPT_CUSTOMMENU) && (item->type != OPT_FUNC_CALL)) {
             write_option_value(item, 0, 0);
             strncpy((char*)osd->osd_array.data[i][1], menu_row2, OSD_CHAR_COLS);
             row_mask[1] |= (1<<i);
@@ -379,13 +399,20 @@ void display_menu(alt_u8 forcedisp)
     if (!forcedisp && !remote_code)
         return;
 
+    // Custom menu function
+    if ((cstm_f != NULL) && (code != PREV_MENU)) {
+        cstm_f(code, 0);
+
+        return;
+    }
+
     item = &navi[navlvl].m->items[navi[navlvl].mp];
 
     // Parse menu control
     switch (code) {
     case PREV_PAGE:
     case NEXT_PAGE:
-        if ((item->type == OPT_FUNC_CALL) || (item->type == OPT_SUBMENU))
+        if ((item->type == OPT_FUNC_CALL) || (item->type == OPT_SUBMENU) || (item->type == OPT_CUSTOMMENU))
             osd->osd_sec_enable[1].mask &= ~(1<<navi[navlvl].mp);
 
         if (code == PREV_PAGE)
@@ -395,11 +422,15 @@ void display_menu(alt_u8 forcedisp)
         break;
     case PREV_MENU:
         if (navlvl > 0) {
-            navlvl--;
+            if (cstm_f != NULL)
+                cstm_f = NULL;
+            else
+                navlvl--;
             render_osd_page();
         } else {
             menu_active = 0;
             osd->osd_config.menu_active = 0;
+            cstm_f = NULL;
             ui_disp_status(0);
             return;
         }
@@ -416,6 +447,10 @@ void display_menu(alt_u8 forcedisp)
                 navlvl++;
                 render_osd_page();
 
+                break;
+            case OPT_CUSTOMMENU:
+                enter_cstm(item, 0);
+                return;
                 break;
             case OPT_FUNC_CALL:
                 retval = item->fun.f();
@@ -492,6 +527,10 @@ void display_menu(alt_u8 forcedisp)
     ui_disp_menu(0);
 }
 
+void set_func_ret_msg(char *msg) {
+    strlcpy(func_ret_status, msg, LCD_ROW_LEN+1);
+}
+
 void update_osd_size(mode_data_t *vm_out) {
     uint8_t osd_size = vm_out->timings.v_active / 700;
     uint8_t par_x4 = (((400*vm_out->timings.h_active*vm_out->ar.v)/((vm_out->timings.v_active<<vm_out->timings.interlaced)*vm_out->ar.h))+50)/100;
@@ -507,13 +546,310 @@ void update_osd_size(mode_data_t *vm_out) {
 }
 
 void refresh_osd() {
-    if (menu_active) {
+    if (menu_active && (cstm_f == NULL)) {
         remote_code = 0;
         render_osd_page();
         display_menu(1);
     }
 }
 
+void osd_array_fname_fill(FILINFO *fno) {
+    // Buffer has space for up to 21 strings
+    if (osd_list_iter < (sizeof(tmpbuf)/24) ) {
+        sniprintf(&tmpbuf[osd_list_iter*24], 24, "%s", fno->fname);
+        strncpy((char*)osd->osd_array.data[osd_list_iter+2][0], &tmpbuf[osd_list_iter*24], OSD_CHAR_COLS);
+    }
+
+    osd_list_iter++;
+}
+
+int load_shmask(char *dirname, char *filename) {
+    FIL f_shmask;
+    char dirname_root[10];
+    int arr_size_loaded=0;
+    int v0=0,v1=0;
+    int p;
+
+    if (!sdcard_dev.mount) {
+        if (file_mount() != 0) {
+            printf("SD card not detected\n");
+            return -1;
+        }
+    }
+
+    sniprintf(dirname_root, sizeof(dirname_root), "/%s", dirname);
+    f_chdir(dirname_root);
+
+    if (!file_open(&f_shmask, filename)) {
+        while (file_get_string(&f_shmask, tmpbuf, sizeof(tmpbuf))) {
+            // strip CR / CRLF
+            tmpbuf[strcspn(tmpbuf, "\r\n")] = 0;
+
+            // Skip empty / comment lines
+            if ((tmpbuf[0] == 0) || (tmpbuf[0] == '#'))
+                continue;
+
+            if (!arr_size_loaded && (sscanf(tmpbuf, "%d,%d", &v0, &v1) == 2)) {
+                c_shmask.arr.iv_x = v0-1;
+                c_shmask.arr.iv_y = v1-1;
+                arr_size_loaded = 1;
+            } else if (arr_size_loaded && (v1 > 0)) {
+                p = c_shmask.arr.iv_y+1-v1;
+                if (sscanf(tmpbuf, "%hx,%hx,%hx,%hx,%hx,%hx,%hx,%hx,%hx,%hx,%hx,%hx,%hx,%hx,%hx,%hx",   &c_shmask.arr.v[p][0],
+                                                                                                        &c_shmask.arr.v[p][1],
+                                                                                                        &c_shmask.arr.v[p][2],
+                                                                                                        &c_shmask.arr.v[p][3],
+                                                                                                        &c_shmask.arr.v[p][4],
+                                                                                                        &c_shmask.arr.v[p][5],
+                                                                                                        &c_shmask.arr.v[p][6],
+                                                                                                        &c_shmask.arr.v[p][7],
+                                                                                                        &c_shmask.arr.v[p][8],
+                                                                                                        &c_shmask.arr.v[p][9],
+                                                                                                        &c_shmask.arr.v[p][10],
+                                                                                                        &c_shmask.arr.v[p][11],
+                                                                                                        &c_shmask.arr.v[p][12],
+                                                                                                        &c_shmask.arr.v[p][13],
+                                                                                                        &c_shmask.arr.v[p][14],
+                                                                                                        &c_shmask.arr.v[p][15]) == v0)
+                    v1--;
+            }
+        }
+
+        file_close(&f_shmask);
+    }
+
+    f_chdir("/");
+
+    sniprintf(c_shmask.name, sizeof(c_shmask.name), "C: %s", filename);
+    shmask_loaded_array = -1;
+    update_sc_config();
+    return 0;
+}
+
+int load_lc_palette_set(char *dirname, char *filename) {
+    FIL f_lc_palset;
+    char dirname_root[10];
+    int entries_remaining=0;
+    int offset;
+
+    if (!sdcard_dev.mount) {
+        if (file_mount() != 0) {
+            printf("SD card not detected\n");
+            return -1;
+        }
+    }
+
+    sniprintf(dirname_root, sizeof(dirname_root), "/%s", dirname);
+    f_chdir(dirname_root);
+
+    if (!file_open(&f_lc_palset, filename)) {
+        while (file_get_string(&f_lc_palset, tmpbuf, sizeof(tmpbuf))) {
+            // strip CR / CRLF
+            tmpbuf[strcspn(tmpbuf, "\r\n")] = 0;
+
+            // Skip empty / comment lines
+            if ((tmpbuf[0] == 0) || (tmpbuf[0] == '#'))
+                continue;
+
+            if (!entries_remaining) {
+                if (strncmp(tmpbuf, "c64_pal", 10) == 0) {
+                    offset = offsetof(lc_palette_set, c64_pal)/4;
+                    entries_remaining = 16;
+                } else if (strncmp(tmpbuf, "zx_pal", 10) == 0) {
+                    offset = offsetof(lc_palette_set, zx_pal)/4;
+                    entries_remaining = 16;
+                } else if (strncmp(tmpbuf, "msx_pal", 10) == 0) {
+                    offset = offsetof(lc_palette_set, msx_pal)/4;
+                    entries_remaining = 16;
+                } else if (strncmp(tmpbuf, "intv_pal", 10) == 0) {
+                    offset = offsetof(lc_palette_set, intv_pal)/4;
+                    entries_remaining = 16;
+                } else if (strncmp(tmpbuf, "nes_pal", 10) == 0) {
+                    offset = offsetof(lc_palette_set, nes_pal)/4;
+                    entries_remaining = 64;
+                } else if (strncmp(tmpbuf, "tia_pal", 10) == 0) {
+                    offset = offsetof(lc_palette_set, tia_pal)/4;
+                    entries_remaining = 128;
+                } else if (strncmp(tmpbuf, "gtia_pal", 10) == 0) {
+                    offset = offsetof(lc_palette_set, gtia_pal)/4;
+                    entries_remaining = 128;
+                }
+            } else if (sscanf(tmpbuf, "%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx",  &c_lc_palette_set.pal.data[offset],
+                                                                                                          &c_lc_palette_set.pal.data[offset+1],
+                                                                                                          &c_lc_palette_set.pal.data[offset+2],
+                                                                                                          &c_lc_palette_set.pal.data[offset+3],
+                                                                                                          &c_lc_palette_set.pal.data[offset+4],
+                                                                                                          &c_lc_palette_set.pal.data[offset+5],
+                                                                                                          &c_lc_palette_set.pal.data[offset+6],
+                                                                                                          &c_lc_palette_set.pal.data[offset+7],
+                                                                                                          &c_lc_palette_set.pal.data[offset+8],
+                                                                                                          &c_lc_palette_set.pal.data[offset+9],
+                                                                                                          &c_lc_palette_set.pal.data[offset+10],
+                                                                                                          &c_lc_palette_set.pal.data[offset+11],
+                                                                                                          &c_lc_palette_set.pal.data[offset+12],
+                                                                                                          &c_lc_palette_set.pal.data[offset+13],
+                                                                                                          &c_lc_palette_set.pal.data[offset+14],
+                                                                                                          &c_lc_palette_set.pal.data[offset+15]) == 16) {
+
+
+                offset += 16;
+                entries_remaining -= 16;
+            }
+        }
+
+        file_close(&f_lc_palset);
+    }
+
+    f_chdir("/");
+
+    sniprintf(c_lc_palette_set.name, sizeof(c_lc_palette_set.name), "C: %s", filename);
+    loaded_lc_palette = -1;
+    update_sc_config();
+    return 0;
+}
+
+void cstm_file_load(menucode_id code, int setup_disp, char *dir, char *pattern, load_func load_f) {
+    uint32_t row_mask[2] = {0x03, 0x00};
+    int i, retval, items_curpage;
+    static int file_load_nav = 0;
+    static int file_load_page = 0;
+    static int files_found;
+
+    FILINFO fno;
+
+    if (!sdcard_dev.mount) {
+        if (file_mount() != 0) {
+            sniprintf(menu_row1, LCD_ROW_LEN+1, "No SD card");
+            sniprintf(menu_row2, LCD_ROW_LEN+1, "detected");
+            ui_disp_menu(1);
+
+            return;
+        }
+    }
+
+    if (setup_disp) {
+        files_found = find_files_exec(dir, pattern, &fno, 0, 99, NULL);
+        printf("%d %s files found\n", files_found, dir);
+
+        if (file_load_page*20+file_load_nav > files_found) {
+            file_load_page = 0;
+            file_load_nav = 0;
+        }
+    }
+
+    if (files_found == 0) {
+        sniprintf(menu_row1, LCD_ROW_LEN+1, "No %s/%s", dir, pattern);
+        sniprintf(menu_row2, LCD_ROW_LEN+1, "files found");
+        ui_disp_menu(1);
+
+        return;
+    }
+
+    // Parse menu control
+    switch (code) {
+    case PREV_PAGE:
+        file_load_nav--;
+        break;
+    case NEXT_PAGE:
+        file_load_nav++;
+        break;
+    case VAL_MINUS:
+        file_load_page = (file_load_page == 0) ? ((files_found-1)/20) : (file_load_page - 1);
+        setup_disp = 1;
+        break;
+    case VAL_PLUS:
+        file_load_page = (file_load_page + 1) % (((files_found-1)/20)+1);
+        setup_disp = 1;
+        break;
+    case OPT_SELECT:
+        find_files_exec(dir, pattern, &fno, 0, file_load_page*20+file_load_nav, NULL);
+        retval = load_f(dir, fno.fname);
+        setup_disp = 1;
+        break;
+    default:
+        break;
+    }
+
+    if (file_load_page > (files_found/20))
+        file_load_page = 0;
+    items_curpage = files_found-file_load_page*20;
+    if (items_curpage > 20)
+        items_curpage = 20;
+
+    if (file_load_nav < 0)
+        file_load_nav = items_curpage-1;
+    else if (file_load_nav >= items_curpage)
+        file_load_nav = 0;
+
+    if (setup_disp) {
+        memset((void*)osd->osd_array.data, 0, sizeof(osd_char_array));
+
+        sniprintf(menu_row1, LCD_ROW_LEN+1, "%s p. %d/%d", dir, file_load_page+1, ((files_found-1)/20)+1);
+        strncpy((char*)osd->osd_array.data[0][0], menu_row1, OSD_CHAR_COLS);
+        for (i=0; i<OSD_CHAR_COLS; i++)
+            osd->osd_array.data[1][0][i] = '-';
+
+        osd_list_iter = 0;
+        find_files_exec(dir, pattern, &fno, file_load_page*20, file_load_page*20+items_curpage-1, osd_array_fname_fill);
+
+        for (i=0; i<items_curpage; i++)
+            row_mask[0] |= (1<<(i+2));
+
+        sniprintf((char*)osd->osd_array.data[items_curpage+3][0], OSD_CHAR_COLS, "< Prev   Next >");
+        row_mask[0] |= (3<<(items_curpage+2));
+
+        if (code == OPT_SELECT) {
+            if (retval == 0)
+                strlcpy(menu_row2, "Done", LCD_ROW_LEN+1);
+            else if (retval < 0)
+                sniprintf(menu_row2, LCD_ROW_LEN+1, "Failed (%d)", retval);
+            else
+                strlcpy(menu_row2, func_ret_status, LCD_ROW_LEN+1);
+
+            strncpy((char*)osd->osd_array.data[file_load_nav+2][1], menu_row2, OSD_CHAR_COLS);
+
+            row_mask[1] = (1<<(file_load_nav+2));
+        }
+
+        osd->osd_sec_enable[0].mask = row_mask[0];
+        osd->osd_sec_enable[1].mask = row_mask[1];
+    }
+
+    osd->osd_row_color.mask = (1<<(file_load_nav+2));
+
+    if (code != OPT_SELECT)
+        sniprintf(menu_row2, LCD_ROW_LEN+1, "%s", &tmpbuf[file_load_nav*24]);
+
+    ui_disp_menu(0);
+}
+
+void cstm_shmask_load(menucode_id code, int setup_disp) {
+    cstm_file_load(code, setup_disp, "shmask", "*.txt", load_shmask);
+}
+
+void cstm_lc_palette_set_load(menucode_id code, int setup_disp) {
+    cstm_file_load(code, setup_disp, "lumacode", "*.txt", load_lc_palette_set);
+}
+
+void cstm_fw_update(menucode_id code, int setup_disp) {
+    cstm_file_load(code, setup_disp, "fw", "*.bin", fw_update);
+}
+
+void enter_cstm(const menuitem_t *item, int detached_mode) {
+    if (detached_mode) {
+        navlvl = 0;
+        menu_active = 1;
+        osd->osd_config.menu_active = menu_active;
+    }
+    /*if (item->type == OPT_AVCONFIG_SELECTION) {
+        lw_item = item;
+        cstm_f = cstm_listview;
+    } else {*/
+        cstm_f = item->cstm.cstm_f;
+    //}
+    cstm_f(NO_ACTION, 1);
+}
+
 static void vm_select() {
     vm_edit = vm_sel;
     tc_h_samplerate = video_modes_plm[vm_edit].timings.h_total;

software/sys_controller/src/userdata.c

@@ -49,6 +49,7 @@ extern mode_data_t video_modes_plm[];
 extern uint8_t update_cur_vm;
 extern SD_DEV sdcard_dev;
 extern c_shmask_t c_shmask;
+extern c_lc_palette_set_t c_lc_palette_set;
 
 char target_profile_name[USERDATA_NAME_LEN+1], cur_profile_name[USERDATA_NAME_LEN+1];
 
@@ -71,6 +72,7 @@ const ude_item_map ude_initcfg_items[] = {
 const ude_item_map ude_profile_items[] = {
     {{0, 120, sizeof(video_modes_plm_default)}, video_modes_plm},
     UDE_ITEM(1, 120, c_shmask),
+    UDE_ITEM(65, 120, c_lc_palette_set),
     // avconfig_t
     UDE_ITEM(2, 120, tc.pm_240p),
     UDE_ITEM(3, 120, tc.pm_384p),
@@ -135,6 +137,8 @@ const ude_item_map ude_profile_items[] = {
     UDE_ITEM(62, 120, tc.full_tx_setup),
     UDE_ITEM(63, 120, tc.av3_alt_rgb),
     UDE_ITEM(64, 120, tc.link_av),
+    // 65 reserved
+    UDE_ITEM(66, 120, tc.panasonic_hack),
 };
 
 int write_userdata(uint8_t entry) {