Changeset 1463 for trunk


Ignore:
Timestamp:
11/10/11 00:40:00 (6 months ago)
Author:
hailfinger
Message:

Register Parallel/LPC/FWH programmers the same way SPI programmers are registered.

All programmers are now calling programmer registration functions and
direct manipulations of buses_supported are not needed/possible anymore.

Note: Programmers without parallel/LPC/FWH chip support should not call
register_par_programmer().

Additional fixes:
Set max_rom_decode.parallel for drkaiser.
Remove abuse of programmer_map_flash_region in it85spi.
Annotate several FIXMEs in it85spi.

Signed-off-by: Carl-Daniel Hailfinger <c-d.hailfinger.devel.2006@…>
Acked-By: Michael Karcher <flashrom@…>

Location:
trunk
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • trunk/atahpt.c

    r1396 r1463  
    4141}; 
    4242 
     43static const struct par_programmer par_programmer_atahpt = { 
     44                .chip_readb             = atahpt_chip_readb, 
     45                .chip_readw             = fallback_chip_readw, 
     46                .chip_readl             = fallback_chip_readl, 
     47                .chip_readn             = fallback_chip_readn, 
     48                .chip_writeb            = atahpt_chip_writeb, 
     49                .chip_writew            = fallback_chip_writew, 
     50                .chip_writel            = fallback_chip_writel, 
     51                .chip_writen            = fallback_chip_writen, 
     52}; 
     53 
    4354static int atahpt_shutdown(void *data) 
    4455{ 
    … …  
    6273        rpci_write_long(pcidev_dev, REG_FLASH_ACCESS, reg32); 
    6374 
    64         buses_supported = BUS_PARALLEL; 
    65  
    6675        if (register_shutdown(atahpt_shutdown, NULL)) 
    6776                return 1; 
     77 
     78        register_par_programmer(&par_programmer_atahpt, BUS_PARALLEL); 
     79 
    6880        return 0; 
    6981} 

  • trunk/board_enable.c

    r1458 r1463  
    426426        if (tmp & 0xf0) { 
    427427                /* The IT8705F will respond to LPC cycles and translate them. */ 
    428                 buses_supported = BUS_PARALLEL; 
     428                internal_buses_supported = BUS_PARALLEL; 
    429429                /* Flash ROM I/F Writes Enable */ 
    430430                tmp |= 0x04; 

  • trunk/chipset_enable.c

    r1461 r1463  
    214214        uint16_t xbcs = 0x4e;   /* X-Bus Chip Select register. */ 
    215215 
    216         buses_supported = BUS_PARALLEL; 
     216        internal_buses_supported = BUS_PARALLEL; 
    217217 
    218218        old = pci_read_word(dev, xbcs); 
    … …  
    304304         * FB_DEC_EN2. 
    305305         */ 
    306         buses_supported = BUS_FWH; 
     306        internal_buses_supported = BUS_FWH; 
    307307        return enable_flash_ich(dev, name, 0x4e); 
    308308} 
    … …  
    413413 
    414414        /* If we're called by enable_flash_ich_dc_spi, it will override 
    415          * buses_supported anyway. 
     415         * internal_buses_supported anyway. 
    416416         */ 
    417         buses_supported = BUS_FWH; 
     417        internal_buses_supported = BUS_FWH; 
    418418        return enable_flash_ich(dev, name, 0xdc); 
    419419} 
    … …  
    435435                rpci_write_byte(dev, 0xd9, new); 
    436436 
    437         buses_supported = BUS_FWH; 
     437        internal_buses_supported = BUS_FWH; 
    438438        return 0; 
    439439} 
    … …  
    469469        if (bnt & 0x02) { 
    470470                /* If strapped to LPC, no SPI initialization is required */ 
    471                 buses_supported = BUS_FWH; 
     471                internal_buses_supported = BUS_FWH; 
    472472                return 0; 
    473473        } 
    474474 
    475475        /* This adds BUS_SPI */ 
    476         buses_supported = BUS_SPI; 
    477476        if (ich_init_spi(dev, tmp, rcrb, 7) != 0) { 
    478477                if (!ret) 
    … …  
    557556         * on ICH7 when the southbridge is strapped to LPC 
    558557         */ 
    559         buses_supported = BUS_FWH; 
     558        internal_buses_supported = BUS_FWH; 
    560559        if (ich_generation == CHIPSET_ICH7) { 
    561560                if (bbs == 0x03) { 
    … …  
    565564                } else { 
    566565                        /* Disable LPC/FWH if strapped to PCI or SPI */ 
    567                         buses_supported = 0; 
     566                        internal_buses_supported = BUS_NONE; 
    568567                } 
    569568        } 
    … …  
    670669#define CS5530_ENABLE_SA20              (1 << 6) 
    671670 
    672         buses_supported = BUS_PARALLEL; 
     671        internal_buses_supported = BUS_PARALLEL; 
    673672        /* Decode 0x000E0000-0x000FFFFF (128 kB), not just 64 kB, and 
    674673         * decode 0xFF000000-0xFFFFFFFF (16 MB), not just 256 kB. 
    … …  
    823822        } 
    824823 
    825         buses_supported = BUS_LPC | BUS_FWH; 
     824        internal_buses_supported = BUS_LPC | BUS_FWH; 
    826825 
    827826        ret = sb600_probe_spi(dev); 
    … …  
    917916        uint8_t tmp; 
    918917 
    919         buses_supported = BUS_PARALLEL; 
     918        internal_buses_supported = BUS_PARALLEL; 
    920919 
    921920        tmp = INB(0xc06); 
    … …  
    10171016        case 0x0: 
    10181017                ret = enable_flash_mcp55(dev, name); 
    1019                 buses_supported = BUS_LPC; 
     1018                internal_buses_supported = BUS_LPC; 
    10201019                msg_pdbg("Flash bus type is LPC\n"); 
    10211020                break; 
    … …  
    10251024                 * Do we really want to disable LPC in this case? 
    10261025                 */ 
    1027                 buses_supported = BUS_NONE; 
     1026                internal_buses_supported = BUS_NONE; 
    10281027                msg_pdbg("Flash bus type is SPI\n"); 
    10291028                msg_pinfo("SPI on this chipset is WIP. Please report any " 
    … …  
    10331032        default: 
    10341033                /* Should not happen. */ 
    1035                 buses_supported = BUS_NONE; 
     1034                internal_buses_supported = BUS_NONE; 
    10361035                msg_pdbg("Flash bus type is unknown (none)\n"); 
    10371036                msg_pinfo("Something went wrong with bus type detection.\n"); 
    … …  
    13261325        int ret = -2;           /* Nothing! */ 
    13271326        int i; 
    1328         char *s; 
    13291327 
    13301328        /* Now let's try to find the chipset we have... */ 
    … …  
    13781376        } 
    13791377 
    1380         s = flashbuses_to_text(buses_supported); 
    1381         msg_pinfo("This chipset supports the following protocols: %s.\n", s); 
    1382         free(s); 
    1383  
    13841378        return ret; 
    13851379} 

  • trunk/cli_classic.c

    r1436 r1463  
    444444                goto out_shutdown; 
    445445        } 
     446        tempstr = flashbuses_to_text(buses_supported); 
     447        msg_pdbg("This programmer supports the following protocols: %s.\n", 
     448                 tempstr); 
     449        free(tempstr); 
    446450 
    447451        for (i = 0; i < ARRAY_SIZE(flashes); i++) { 

  • trunk/drkaiser.c

    r1397 r1463  
    4040static uint8_t *drkaiser_bar; 
    4141 
     42static const struct par_programmer par_programmer_drkaiser = { 
     43                .chip_readb             = drkaiser_chip_readb, 
     44                .chip_readw             = fallback_chip_readw, 
     45                .chip_readl             = fallback_chip_readl, 
     46                .chip_readn             = fallback_chip_readn, 
     47                .chip_writeb            = drkaiser_chip_writeb, 
     48                .chip_writew            = fallback_chip_writew, 
     49                .chip_writel            = fallback_chip_writel, 
     50                .chip_writen            = fallback_chip_writen, 
     51}; 
     52 
    4253static int drkaiser_shutdown(void *data) 
    4354{ 
    … …  
    6576                               addr, DRKAISER_MEMMAP_SIZE); 
    6677 
    67         buses_supported = BUS_PARALLEL; 
    68  
    6978        if (register_shutdown(drkaiser_shutdown, NULL)) 
    7079                return 1; 
     80 
     81        max_rom_decode.parallel = 128 * 1024; 
     82        register_par_programmer(&par_programmer_drkaiser, BUS_PARALLEL); 
     83 
    7184        return 0; 
    7285} 

  • trunk/dummyflasher.c

    r1450 r1463  
    7676}; 
    7777 
     78static const struct par_programmer par_programmer_dummy = { 
     79                .chip_readb             = dummy_chip_readb, 
     80                .chip_readw             = dummy_chip_readw, 
     81                .chip_readl             = dummy_chip_readl, 
     82                .chip_readn             = dummy_chip_readn, 
     83                .chip_writeb            = dummy_chip_writeb, 
     84                .chip_writew            = dummy_chip_writew, 
     85                .chip_writel            = dummy_chip_writel, 
     86                .chip_writen            = dummy_chip_writen, 
     87}; 
     88 
     89enum chipbustype dummy_buses_supported = BUS_NONE; 
     90 
    7891static int dummy_shutdown(void *data) 
    7992{ 
    … …  
    109122        tolower_string(bustext); 
    110123 
    111         buses_supported = BUS_NONE; 
     124        dummy_buses_supported = BUS_NONE; 
    112125        if (strstr(bustext, "parallel")) { 
    113                 buses_supported |= BUS_PARALLEL; 
     126                dummy_buses_supported |= BUS_PARALLEL; 
    114127                msg_pdbg("Enabling support for %s flash.\n", "parallel"); 
    115128        } 
    116129        if (strstr(bustext, "lpc")) { 
    117                 buses_supported |= BUS_LPC; 
     130                dummy_buses_supported |= BUS_LPC; 
    118131                msg_pdbg("Enabling support for %s flash.\n", "LPC"); 
    119132        } 
    120133        if (strstr(bustext, "fwh")) { 
    121                 buses_supported |= BUS_FWH; 
     134                dummy_buses_supported |= BUS_FWH; 
    122135                msg_pdbg("Enabling support for %s flash.\n", "FWH"); 
    123136        } 
    124137        if (strstr(bustext, "spi")) { 
    125                 register_spi_programmer(&spi_programmer_dummyflasher); 
     138                dummy_buses_supported |= BUS_SPI; 
    126139                msg_pdbg("Enabling support for %s flash.\n", "SPI"); 
    127140        } 
    128         if (buses_supported == BUS_NONE) 
     141        if (dummy_buses_supported == BUS_NONE) 
    129142                msg_pdbg("Support for all flash bus types disabled.\n"); 
    130143        free(bustext); 
    … …  
    227240                return 1; 
    228241        } 
     242        if (dummy_buses_supported & (BUS_PARALLEL | BUS_LPC | BUS_FWH)) 
     243                register_par_programmer(&par_programmer_dummy, 
     244                                        dummy_buses_supported & 
     245                                                (BUS_PARALLEL | BUS_LPC | 
     246                                                 BUS_FWH)); 
     247        if (dummy_buses_supported & BUS_SPI) 
     248                register_spi_programmer(&spi_programmer_dummyflasher); 
     249 
    229250        return 0; 
    230251} 

  • trunk/flashrom.c

    r1450 r1463  
    6969                .map_flash_region       = physmap, 
    7070                .unmap_flash_region     = physunmap, 
    71                 .chip_readb             = internal_chip_readb, 
    72                 .chip_readw             = internal_chip_readw, 
    73                 .chip_readl             = internal_chip_readl, 
    74                 .chip_readn             = internal_chip_readn, 
    75                 .chip_writeb            = internal_chip_writeb, 
    76                 .chip_writew            = internal_chip_writew, 
    77                 .chip_writel            = internal_chip_writel, 
    78                 .chip_writen            = fallback_chip_writen, 
    7971                .delay                  = internal_delay, 
    8072        }, 
    … …  
    8779                .map_flash_region       = dummy_map, 
    8880                .unmap_flash_region     = dummy_unmap, 
    89                 .chip_readb             = dummy_chip_readb, 
    90                 .chip_readw             = dummy_chip_readw, 
    91                 .chip_readl             = dummy_chip_readl, 
    92                 .chip_readn             = dummy_chip_readn, 
    93                 .chip_writeb            = dummy_chip_writeb, 
    94                 .chip_writew            = dummy_chip_writew, 
    95                 .chip_writel            = dummy_chip_writel, 
    96                 .chip_writen            = dummy_chip_writen, 
    9781                .delay                  = internal_delay, 
    9882        }, 
    … …  
    10589                .map_flash_region       = fallback_map, 
    10690                .unmap_flash_region     = fallback_unmap, 
    107                 .chip_readb             = nic3com_chip_readb, 
    108                 .chip_readw             = fallback_chip_readw, 
    109                 .chip_readl             = fallback_chip_readl, 
    110                 .chip_readn             = fallback_chip_readn, 
    111                 .chip_writeb            = nic3com_chip_writeb, 
    112                 .chip_writew            = fallback_chip_writew, 
    113                 .chip_writel            = fallback_chip_writel, 
    114                 .chip_writen            = fallback_chip_writen, 
    11591                .delay                  = internal_delay, 
    11692        }, 
    … …  
    125101                .map_flash_region       = fallback_map, 
    126102                .unmap_flash_region     = fallback_unmap, 
    127                 .chip_readb             = nicrealtek_chip_readb, 
    128                 .chip_readw             = fallback_chip_readw, 
    129                 .chip_readl             = fallback_chip_readl, 
    130                 .chip_readn             = fallback_chip_readn, 
    131                 .chip_writeb            = nicrealtek_chip_writeb, 
    132                 .chip_writew            = fallback_chip_writew, 
    133                 .chip_writel            = fallback_chip_writel, 
    134                 .chip_writen            = fallback_chip_writen, 
    135103                .delay                  = internal_delay, 
    136104        }, 
    … …  
    143111                .map_flash_region       = fallback_map, 
    144112                .unmap_flash_region     = fallback_unmap, 
    145                 .chip_readb             = nicnatsemi_chip_readb, 
    146                 .chip_readw             = fallback_chip_readw, 
    147                 .chip_readl             = fallback_chip_readl, 
    148                 .chip_readn             = fallback_chip_readn, 
    149                 .chip_writeb            = nicnatsemi_chip_writeb, 
    150                 .chip_writew            = fallback_chip_writew, 
    151                 .chip_writel            = fallback_chip_writel, 
    152                 .chip_writen            = fallback_chip_writen, 
    153113                .delay                  = internal_delay, 
    154114        }, 
    … …  
    161121                .map_flash_region       = fallback_map, 
    162122                .unmap_flash_region     = fallback_unmap, 
    163                 .chip_readb             = gfxnvidia_chip_readb, 
    164                 .chip_readw             = fallback_chip_readw, 
    165                 .chip_readl             = fallback_chip_readl, 
    166                 .chip_readn             = fallback_chip_readn, 
    167                 .chip_writeb            = gfxnvidia_chip_writeb, 
    168                 .chip_writew            = fallback_chip_writew, 
    169                 .chip_writel            = fallback_chip_writel, 
    170                 .chip_writen            = fallback_chip_writen, 
    171123                .delay                  = internal_delay, 
    172124        }, 
    … …  
    179131                .map_flash_region       = fallback_map, 
    180132                .unmap_flash_region     = fallback_unmap, 
    181                 .chip_readb             = drkaiser_chip_readb, 
    182                 .chip_readw             = fallback_chip_readw, 
    183                 .chip_readl             = fallback_chip_readl, 
    184                 .chip_readn             = fallback_chip_readn, 
    185                 .chip_writeb            = drkaiser_chip_writeb, 
    186                 .chip_writew            = fallback_chip_writew, 
    187                 .chip_writel            = fallback_chip_writel, 
    188                 .chip_writen            = fallback_chip_writen, 
    189133                .delay                  = internal_delay, 
    190134        }, 
    … …  
    197141                .map_flash_region       = fallback_map, 
    198142                .unmap_flash_region     = fallback_unmap, 
    199                 .chip_readb             = satasii_chip_readb, 
    200                 .chip_readw             = fallback_chip_readw, 
    201                 .chip_readl             = fallback_chip_readl, 
    202                 .chip_readn             = fallback_chip_readn, 
    203                 .chip_writeb            = satasii_chip_writeb, 
    204                 .chip_writew            = fallback_chip_writew, 
    205                 .chip_writel            = fallback_chip_writel, 
    206                 .chip_writen            = fallback_chip_writen, 
    207143                .delay                  = internal_delay, 
    208144        }, 
    … …  
    215151                .map_flash_region       = fallback_map, 
    216152                .unmap_flash_region     = fallback_unmap, 
    217                 .chip_readb             = atahpt_chip_readb, 
    218                 .chip_readw             = fallback_chip_readw, 
    219                 .chip_readl             = fallback_chip_readl, 
    220                 .chip_readn             = fallback_chip_readn, 
    221                 .chip_writeb            = atahpt_chip_writeb, 
    222                 .chip_writew            = fallback_chip_writew, 
    223                 .chip_writel            = fallback_chip_writel, 
    224                 .chip_writen            = fallback_chip_writen, 
    225153                .delay                  = internal_delay, 
    226154        }, 
    … …  
    233161                .map_flash_region       = fallback_map, 
    234162                .unmap_flash_region     = fallback_unmap, 
    235                 .chip_readb             = noop_chip_readb, 
    236                 .chip_readw             = fallback_chip_readw, 
    237                 .chip_readl             = fallback_chip_readl, 
    238                 .chip_readn             = fallback_chip_readn, 
    239                 .chip_writeb            = noop_chip_writeb, 
    240                 .chip_writew            = fallback_chip_writew, 
    241                 .chip_writel            = fallback_chip_writel, 
    242                 .chip_writen            = fallback_chip_writen, 
    243163                .delay                  = internal_delay, 
    244164        }, 
    … …  
    251171                .map_flash_region       = fallback_map, 
    252172                .unmap_flash_region     = fallback_unmap, 
    253                 .chip_readb             = serprog_chip_readb, 
    254                 .chip_readw             = fallback_chip_readw, 
    255                 .chip_readl             = fallback_chip_readl, 
    256                 .chip_readn             = serprog_chip_readn, 
    257                 .chip_writeb            = serprog_chip_writeb, 
    258                 .chip_writew            = fallback_chip_writew, 
    259                 .chip_writel            = fallback_chip_writel, 
    260                 .chip_writen            = fallback_chip_writen, 
    261173                .delay                  = serprog_delay, 
    262174        }, 
    … …  
    269181                .map_flash_region       = fallback_map, 
    270182                .unmap_flash_region     = fallback_unmap, 
    271                 .chip_readb             = noop_chip_readb, 
    272                 .chip_readw             = fallback_chip_readw, 
    273                 .chip_readl             = fallback_chip_readl, 
    274                 .chip_readn             = fallback_chip_readn, 
    275                 .chip_writeb            = noop_chip_writeb, 
    276                 .chip_writew            = fallback_chip_writew, 
    277                 .chip_writel            = fallback_chip_writel, 
    278                 .chip_writen            = fallback_chip_writen, 
    279183                .delay                  = internal_delay, 
    280184        }, 
    … …  
    287191                .map_flash_region       = fallback_map, 
    288192                .unmap_flash_region     = fallback_unmap, 
    289                 .chip_readb             = noop_chip_readb, 
    290                 .chip_readw             = fallback_chip_readw, 
    291                 .chip_readl             = fallback_chip_readl, 
    292                 .chip_readn             = fallback_chip_readn, 
    293                 .chip_writeb            = noop_chip_writeb, 
    294                 .chip_writew            = fallback_chip_writew, 
    295                 .chip_writel            = fallback_chip_writel, 
    296                 .chip_writen            = fallback_chip_writen, 
    297193                .delay                  = internal_delay, 
    298194        }, 
    … …  
    305201                .map_flash_region       = fallback_map, 
    306202                .unmap_flash_region     = fallback_unmap, 
    307                 .chip_readb             = noop_chip_readb, 
    308                 .chip_readw             = fallback_chip_readw, 
    309                 .chip_readl             = fallback_chip_readl, 
    310                 .chip_readn             = fallback_chip_readn, 
    311                 .chip_writeb            = noop_chip_writeb, 
    312                 .chip_writew            = fallback_chip_writew, 
    313                 .chip_writel            = fallback_chip_writel, 
    314                 .chip_writen            = fallback_chip_writen, 
    315203                .delay                  = internal_delay, 
    316204        }, 
    … …  
    323211                .map_flash_region       = fallback_map, 
    324212                .unmap_flash_region     = fallback_unmap, 
    325                 .chip_readb             = nicintel_chip_readb, 
    326                 .chip_readw             = fallback_chip_readw, 
    327                 .chip_readl             = fallback_chip_readl, 
    328                 .chip_readn             = fallback_chip_readn, 
    329                 .chip_writeb            = nicintel_chip_writeb, 
    330                 .chip_writew            = fallback_chip_writew, 
    331                 .chip_writel            = fallback_chip_writel, 
    332                 .chip_writen            = fallback_chip_writen, 
    333213                .delay                  = internal_delay, 
    334214        }, 
    … …  
    341221                .map_flash_region       = fallback_map, 
    342222                .unmap_flash_region     = fallback_unmap, 
    343                 .chip_readb             = noop_chip_readb, 
    344                 .chip_readw             = fallback_chip_readw, 
    345                 .chip_readl             = fallback_chip_readl, 
    346                 .chip_readn             = fallback_chip_readn, 
    347                 .chip_writeb            = noop_chip_writeb, 
    348                 .chip_writew            = fallback_chip_writew, 
    349                 .chip_writel            = fallback_chip_writel, 
    350                 .chip_writen            = fallback_chip_writen, 
    351223                .delay                  = internal_delay, 
    352224        }, 
    … …  
    359231                .map_flash_region       = fallback_map, 
    360232                .unmap_flash_region     = fallback_unmap, 
    361                 .chip_readb             = noop_chip_readb, 
    362                 .chip_readw             = fallback_chip_readw, 
    363                 .chip_readl             = fallback_chip_readl, 
    364                 .chip_readn             = fallback_chip_readn, 
    365                 .chip_writeb            = noop_chip_writeb, 
    366                 .chip_writew            = fallback_chip_writew, 
    367                 .chip_writel            = fallback_chip_writel, 
    368                 .chip_writen            = fallback_chip_writen, 
    369233                .delay                  = internal_delay, 
    370234        }, 
    … …  
    377241                .map_flash_region       = fallback_map, 
    378242                .unmap_flash_region     = fallback_unmap, 
    379                 .chip_readb             = satamv_chip_readb, 
    380                 .chip_readw             = fallback_chip_readw, 
    381                 .chip_readl             = fallback_chip_readl, 
    382                 .chip_readn             = fallback_chip_readn, 
    383                 .chip_writeb            = satamv_chip_writeb, 
    384                 .chip_writew            = fallback_chip_writew, 
    385                 .chip_writel            = fallback_chip_writel, 
    386                 .chip_writen            = fallback_chip_writen, 
    387243                .delay                  = internal_delay, 
    388244        }, 
    … …  
    395251                .map_flash_region       = fallback_map, 
    396252                .unmap_flash_region     = fallback_unmap, 
    397                 .chip_readb             = noop_chip_readb, 
    398                 .chip_readw             = fallback_chip_readw, 
    399                 .chip_readl             = fallback_chip_readl, 
    400                 .chip_readn             = fallback_chip_readn, 
    401                 .chip_writeb            = noop_chip_writeb, 
    402                 .chip_writew            = fallback_chip_writew, 
    403                 .chip_writel            = fallback_chip_writel, 
    404                 .chip_writen            = fallback_chip_writen, 
    405253                .delay                  = internal_delay, 
    406254        }, 
    … …  
    514362void chip_writeb(uint8_t val, chipaddr addr) 
    515363{ 
    516         programmer_table[programmer].chip_writeb(val, addr); 
     364        par_programmer->chip_writeb(val, addr); 
    517365} 
    518366 
    519367void chip_writew(uint16_t val, chipaddr addr) 
    520368{ 
    521         programmer_table[programmer].chip_writew(val, addr); 
     369        par_programmer->chip_writew(val, addr); 
    522370} 
    523371 
    524372void chip_writel(uint32_t val, chipaddr addr) 
    525373{ 
    526         programmer_table[programmer].chip_writel(val, addr); 
     374        par_programmer->chip_writel(val, addr); 
    527375} 
    528376 
    529377void chip_writen(uint8_t *buf, chipaddr addr, size_t len) 
    530378{ 
    531         programmer_table[programmer].chip_writen(buf, addr, len); 
     379        par_programmer->chip_writen(buf, addr, len); 
    532380} 
    533381 
    534382uint8_t chip_readb(const chipaddr addr) 
    535383{ 
    536         return programmer_table[programmer].chip_readb(addr); 
     384        return par_programmer->chip_readb(addr); 
    537385} 
    538386 
    539387uint16_t chip_readw(const chipaddr addr) 
    540388{ 
    541         return programmer_table[programmer].chip_readw(addr); 
     389        return par_programmer->chip_readw(addr); 
    542390} 
    543391 
    544392uint32_t chip_readl(const chipaddr addr) 
    545393{ 
    546         return programmer_table[programmer].chip_readl(addr); 
     394        return par_programmer->chip_readl(addr); 
    547395} 
    548396 
    549397void chip_readn(uint8_t *buf, chipaddr addr, size_t len) 
    550398{ 
    551         programmer_table[programmer].chip_readn(buf, addr, len); 
     399        par_programmer->chip_readn(buf, addr, len); 
    552400} 
    553401 

  • trunk/gfxnvidia.c

    r1397 r1463  
    6262}; 
    6363 
     64static const struct par_programmer par_programmer_gfxnvidia = { 
     65                .chip_readb             = gfxnvidia_chip_readb, 
     66                .chip_readw             = fallback_chip_readw, 
     67                .chip_readl             = fallback_chip_readl, 
     68                .chip_readn             = fallback_chip_readn, 
     69                .chip_writeb            = gfxnvidia_chip_writeb, 
     70                .chip_writew            = fallback_chip_writew, 
     71                .chip_writel            = fallback_chip_writel, 
     72                .chip_writen            = fallback_chip_writen, 
     73}; 
     74 
    6475static int gfxnvidia_shutdown(void *data) 
    6576{ 
    … …  
    95106        rpci_write_long(pcidev_dev, 0x50, reg32); 
    96107 
    97         buses_supported = BUS_PARALLEL; 
    98  
    99108        /* Write/erase doesn't work. */ 
    100109        programmer_may_write = 0; 
     110        register_par_programmer(&par_programmer_gfxnvidia, BUS_PARALLEL); 
    101111 
    102112        return 0; 

  • trunk/ichspi.c

    r1462 r1463  
    17971797 
    17981798        /* Not sure if it speaks all these bus protocols. */ 
    1799         buses_supported = BUS_LPC | BUS_FWH; 
     1799        internal_buses_supported = BUS_LPC | BUS_FWH; 
    18001800        ich_generation = CHIPSET_ICH7; 
    18011801        register_spi_programmer(&spi_programmer_via); 

  • trunk/internal.c

    r1440 r1463  
    128128int laptop_ok = 0; 
    129129 
     130static const struct par_programmer par_programmer_internal = { 
     131                .chip_readb             = internal_chip_readb, 
     132                .chip_readw             = internal_chip_readw, 
     133                .chip_readl             = internal_chip_readl, 
     134                .chip_readn             = internal_chip_readn, 
     135                .chip_writeb            = internal_chip_writeb, 
     136                .chip_writew            = internal_chip_writew, 
     137                .chip_writel            = internal_chip_writel, 
     138                .chip_writen            = fallback_chip_writen, 
     139}; 
     140 
     141enum chipbustype internal_buses_supported = BUS_NONE; 
     142 
    130143static int internal_shutdown(void *data) 
    131144{ 
    … …  
    192205 
    193206        /* Default to Parallel/LPC/FWH flash devices. If a known host controller 
    194          * is found, the init routine sets the buses_supported bitfield. 
    195          */ 
    196         buses_supported = BUS_NONSPI; 
     207         * is found, the host controller init routine sets the 
     208         * internal_buses_supported bitfield. 
     209         */ 
     210        internal_buses_supported = BUS_NONSPI; 
    197211 
    198212        /* Initialize PCI access for flash enables */ 
    … …  
    288302         */ 
    289303#if defined(__i386__) || defined(__x86_64__) || defined (__mips) 
     304        register_par_programmer(&par_programmer_internal, internal_buses_supported); 
    290305        return 0; 
    291306#else 

  • trunk/it85spi.c

    r1414 r1463  
    258258#endif 
    259259#ifdef LPC_MEMORY 
    260         base = (chipaddr)programmer_map_flash_region("it85 communication", 
    261                                                      0xFFFFF000, 0x1000); 
     260        /* FIXME: We should block accessing that region for anything else. 
     261         * Major TODO here, and it will be a lot of work. 
     262         */ 
     263        base = (chipaddr)physmap("it85 communication", 0xFFFFF000, 0x1000); 
    262264        msg_pdbg("%s():%d base=0x%08x\n", __func__, __LINE__, 
    263265                 (unsigned int)base); 
    … …  
    286288        int ret; 
    287289 
    288         if (!(buses_supported & BUS_FWH)) { 
     290        if (!(internal_buses_supported & BUS_FWH)) { 
    289291                msg_pdbg("%s():%d buses not support FWH\n", __func__, __LINE__); 
    290292                return 1; 
    … …  
    293295        msg_pdbg("FWH: %s():%d ret=%d\n", __func__, __LINE__, ret); 
    294296        if (!ret) { 
    295                 msg_pdbg("%s():%d buses_supported=0x%x\n", __func__, __LINE__, 
    296                           buses_supported); 
    297                 if (buses_supported & BUS_FWH) 
    298                         msg_pdbg("Overriding chipset SPI with IT85 FWH|SPI.\n"); 
    299                 /* Really leave FWH enabled? */ 
     297                msg_pdbg("%s: internal_buses_supported=0x%x\n", __func__, 
     298                          internal_buses_supported); 
     299                /* Check for FWH because IT85 listens to FWH cycles. 
     300                 * FIXME: The big question is whether FWH cycles are necessary 
     301                 * for communication even if LPC_IO is defined. 
     302                 */ 
     303                if (internal_buses_supported & BUS_FWH) 
     304                        msg_pdbg("Registering IT85 SPI.\n"); 
     305                /* FIXME: Really leave FWH enabled? We can't use this region 
     306                 * anymore since accessing it would mess up IT85 communication. 
     307                 * If we decide to disable FWH for this region, we should print 
     308                 * a debug message about it. 
     309                 */ 
    300310                /* Set this as SPI controller. */ 
    301311                register_spi_programmer(&spi_programmer_it85xx); 

  • trunk/it87spi.c

    r1450 r1463  
    193193        exit_conf_mode_ite(port); 
    194194        it8716f_flashport = flashport; 
    195         if (buses_supported & BUS_SPI) 
     195        if (internal_buses_supported & BUS_SPI) 
    196196                msg_pdbg("Overriding chipset SPI with IT87 SPI.\n"); 
    197197        /* FIXME: Add the SPI bus or replace the other buses with it? */ 

  • trunk/nic3com.c

    r1396 r1463  
    5656}; 
    5757 
     58static const struct par_programmer par_programmer_nic3com = { 
     59                .chip_readb             = nic3com_chip_readb, 
     60                .chip_readw             = fallback_chip_readw, 
     61                .chip_readl             = fallback_chip_readl, 
     62                .chip_readn             = fallback_chip_readn, 
     63                .chip_writeb            = nic3com_chip_writeb, 
     64                .chip_writew            = fallback_chip_writew, 
     65                .chip_writel            = fallback_chip_writel, 
     66                .chip_writen            = fallback_chip_writen, 
     67}; 
     68 
    5869static int nic3com_shutdown(void *data) 
    5970{ 
    … …  
    97108        OUTW(SELECT_REG_WINDOW + 0, io_base_addr + INT_STATUS); 
    98109 
    99         buses_supported = BUS_PARALLEL; 
    100         max_rom_decode.parallel = 128 * 1024; 
    101  
    102110        if (register_shutdown(nic3com_shutdown, NULL)) 
    103111                return 1; 
     112 
     113        max_rom_decode.parallel = 128 * 1024; 
     114        register_par_programmer(&par_programmer_nic3com, BUS_PARALLEL); 
     115 
    104116        return 0; 
    105117} 

  • trunk/nicintel.c

    r1425 r1463  
    4343 
    4444#define CSR_FCR 0x0c 
     45 
     46static const struct par_programmer par_programmer_nicintel = { 
     47                .chip_readb             = nicintel_chip_readb, 
     48                .chip_readw             = fallback_chip_readw, 
     49                .chip_readl             = fallback_chip_readl, 
     50                .chip_readn             = fallback_chip_readn, 
     51                .chip_writeb            = nicintel_chip_writeb, 
     52                .chip_writew            = fallback_chip_writew, 
     53                .chip_writel            = fallback_chip_writel, 
     54                .chip_writen            = fallback_chip_writen, 
     55}; 
    4556 
    4657static int nicintel_shutdown(void *data) 
    … …  
    94105        pci_rmmio_writew(0x0001, nicintel_control_bar + CSR_FCR); 
    95106 
    96         buses_supported = BUS_PARALLEL; 
    97  
    98107        max_rom_decode.parallel = NICINTEL_MEMMAP_SIZE; 
     108        register_par_programmer(&par_programmer_nicintel, BUS_PARALLEL); 
    99109 
    100110        return 0; 

  • trunk/nicnatsemi.c

    r1396 r1463  
    3636}; 
    3737 
     38static const struct par_programmer par_programmer_nicnatsemi = { 
     39                .chip_readb             = nicnatsemi_chip_readb, 
     40                .chip_readw             = fallback_chip_readw, 
     41                .chip_readl             = fallback_chip_readl, 
     42                .chip_readn             = fallback_chip_readn, 
     43                .chip_writeb            = nicnatsemi_chip_writeb, 
     44                .chip_writew            = fallback_chip_writew, 
     45                .chip_writel            = fallback_chip_writel, 
     46                .chip_writen            = fallback_chip_writen, 
     47}; 
     48 
    3849static int nicnatsemi_shutdown(void *data) 
    3950{ 
    … …  
    4960        io_base_addr = pcidev_init(PCI_BASE_ADDRESS_0, nics_natsemi); 
    5061 
    51         buses_supported = BUS_PARALLEL; 
     62        if (register_shutdown(nicnatsemi_shutdown, NULL)) 
     63                return 1; 
    5264 
    5365        /* The datasheet shows address lines MA0-MA16 in one place and MA0-MA15 
    … …  
    5870         */ 
    5971        max_rom_decode.parallel = 131072; 
     72        register_par_programmer(&par_programmer_nicnatsemi, BUS_PARALLEL); 
    6073 
    61         if (register_shutdown(nicnatsemi_shutdown, NULL)) 
    62                 return 1; 
    6374        return 0; 
    6475} 

  • trunk/nicrealtek.c

    r1396 r1463  
    3737}; 
    3838 
     39static const struct par_programmer par_programmer_nicrealtek = { 
     40                .chip_readb             = nicrealtek_chip_readb, 
     41                .chip_readw             = fallback_chip_readw, 
     42                .chip_readl             = fallback_chip_readl, 
     43                .chip_readn             = fallback_chip_readn, 
     44                .chip_writeb            = nicrealtek_chip_writeb, 
     45                .chip_writew            = fallback_chip_writew, 
     46                .chip_writel            = fallback_chip_writel, 
     47                .chip_writen            = fallback_chip_writen, 
     48}; 
     49 
    3950static int nicrealtek_shutdown(void *data) 
    4051{ 
    … …  
    5162        io_base_addr = pcidev_init(PCI_BASE_ADDRESS_0, nics_realtek); 
    5263 
    53         buses_supported = BUS_PARALLEL; 
    54  
    5564        if (register_shutdown(nicrealtek_shutdown, NULL)) 
    5665                return 1; 
     66 
     67        register_par_programmer(&par_programmer_nicrealtek, BUS_PARALLEL); 
     68 
    5769        return 0; 
    5870} 

  • trunk/programmer.c

    r1255 r1463  
    2020 
    2121#include "flash.h" 
     22#include "programmer.h" 
     23 
     24static const struct par_programmer par_programmer_none = { 
     25                .chip_readb             = noop_chip_readb, 
     26                .chip_readw             = fallback_chip_readw, 
     27                .chip_readl             = fallback_chip_readl, 
     28                .chip_readn             = fallback_chip_readn, 
     29                .chip_writeb            = noop_chip_writeb, 
     30                .chip_writew            = fallback_chip_writew, 
     31                .chip_writel            = fallback_chip_writel, 
     32                .chip_writen            = fallback_chip_writen, 
     33}; 
     34 
     35const struct par_programmer *par_programmer = &par_programmer_none; 
    2236 
    2337/* No-op shutdown() for programmers which don't need special handling */ 
    … …  
    97111        return; 
    98112} 
     113 
     114void register_par_programmer(const struct par_programmer *pgm, const enum chipbustype buses) 
     115{ 
     116        par_programmer = pgm; 
     117        buses_supported |= buses; 
     118} 

  • trunk/programmer.h

    r1460 r1463  
    9898        void (*unmap_flash_region) (void *virt_addr, size_t len); 
    9999 
    100         void (*chip_writeb) (uint8_t val, chipaddr addr); 
    101         void (*chip_writew) (uint16_t val, chipaddr addr); 
    102         void (*chip_writel) (uint32_t val, chipaddr addr); 
    103         void (*chip_writen) (uint8_t *buf, chipaddr addr, size_t len); 
    104         uint8_t (*chip_readb) (const chipaddr addr); 
    105         uint16_t (*chip_readw) (const chipaddr addr); 
    106         uint32_t (*chip_readl) (const chipaddr addr); 
    107         void (*chip_readn) (uint8_t *buf, const chipaddr addr, size_t len); 
    108100        void (*delay) (int usecs); 
    109101}; 
    … …  
    307299void probe_superio(void); 
    308300int register_superio(struct superio s); 
     301extern enum chipbustype internal_buses_supported; 
    309302int internal_init(void); 
    310303void internal_chip_writeb(uint8_t val, chipaddr addr); 
    … …  
    361354uint32_t fallback_chip_readl(const chipaddr addr); 
    362355void fallback_chip_readn(uint8_t *buf, const chipaddr addr, size_t len); 
     356struct par_programmer { 
     357        void (*chip_writeb) (uint8_t val, chipaddr addr); 
     358        void (*chip_writew) (uint16_t val, chipaddr addr); 
     359        void (*chip_writel) (uint32_t val, chipaddr addr); 
     360        void (*chip_writen) (uint8_t *buf, chipaddr addr, size_t len); 
     361        uint8_t (*chip_readb) (const chipaddr addr); 
     362        uint16_t (*chip_readw) (const chipaddr addr); 
     363        uint32_t (*chip_readl) (const chipaddr addr); 
     364        void (*chip_readn) (uint8_t *buf, const chipaddr addr, size_t len); 
     365}; 
     366extern const struct par_programmer *par_programmer; 
     367void register_par_programmer(const struct par_programmer *pgm, const enum chipbustype buses); 
    363368 
    364369/* dummyflasher.c */ 
    … …  
    635640void serprog_chip_readn(uint8_t *buf, const chipaddr addr, size_t len); 
    636641void serprog_delay(int usecs); 
    637 int serprog_spi_send_command(unsigned int writecnt, unsigned int readcnt, 
    638                              const unsigned char *writearr, 
    639                              unsigned char *readarr); 
    640 int serprog_spi_read(struct flashchip *flash, uint8_t *buf, int start, int len); 
    641642#endif 
    642643 

  • trunk/satamv.c

    r1396 r1463  
    4141#define PCI_BAR2_CONTROL                0x00c08 
    4242#define GPIO_PORT_CONTROL               0x104f0 
     43 
     44static const struct par_programmer par_programmer_satamv = { 
     45                .chip_readb             = satamv_chip_readb, 
     46                .chip_readw             = fallback_chip_readw, 
     47                .chip_readl             = fallback_chip_readl, 
     48                .chip_readn             = fallback_chip_readn, 
     49                .chip_writeb            = satamv_chip_writeb, 
     50                .chip_writew            = fallback_chip_writew, 
     51                .chip_writel            = fallback_chip_writel, 
     52                .chip_writen            = fallback_chip_writen, 
     53}; 
    4354 
    4455static int satamv_shutdown(void *data) 
    … …  
    138149        msg_pspew("Activating I/O BAR at 0x%04x\n", mv_iobar); 
    139150 
    140         buses_supported = BUS_PARALLEL; 
    141  
    142151        /* 512 kByte with two 8-bit latches, and 
    143152         * 4 MByte with additional 3-bit latch. */ 
    144153        max_rom_decode.parallel = 4 * 1024 * 1024; 
     154        register_par_programmer(&par_programmer_satamv, BUS_PARALLEL); 
    145155 
    146156        return 0; 

  • trunk/satasii.c

    r1396 r1463  
    4343}; 
    4444 
     45static const struct par_programmer par_programmer_satasii = { 
     46                .chip_readb             = satasii_chip_readb, 
     47                .chip_readw             = fallback_chip_readw, 
     48                .chip_readl             = fallback_chip_readl, 
     49                .chip_readn             = fallback_chip_readn, 
     50                .chip_writeb            = satasii_chip_writeb, 
     51                .chip_writew            = fallback_chip_writew, 
     52                .chip_writel            = fallback_chip_writel, 
     53                .chip_writen            = fallback_chip_writen, 
     54}; 
     55 
    4556static int satasii_shutdown(void *data) 
    4657{ 
    … …  
    7788                msg_pinfo("Warning: Flash seems unconnected.\n"); 
    7889 
    79         buses_supported = BUS_PARALLEL; 
    80  
    8190        if (register_shutdown(satasii_shutdown, NULL)) 
    8291                return 1; 
     92 
     93        register_par_programmer(&par_programmer_satasii, BUS_PARALLEL); 
     94 
    8395        return 0; 
    8496} 

  • trunk/serprog.c

    r1456 r1463  
    300300} 
    301301 
     302static int serprog_spi_send_command(unsigned int writecnt, unsigned int readcnt, 
     303                                    const unsigned char *writearr, 
     304                                    unsigned char *readarr); 
     305static int serprog_spi_read(struct flashchip *flash, uint8_t *buf, int start, 
     306                            int len); 
    302307static struct spi_programmer spi_programmer_serprog = { 
    303308        .type           = SPI_CONTROLLER_SERPROG, 
    … …  
    310315}; 
    311316 
     317static const struct par_programmer par_programmer_serprog = { 
     318                .chip_readb             = serprog_chip_readb, 
     319                .chip_readw             = fallback_chip_readw, 
     320                .chip_readl             = fallback_chip_readl, 
     321                .chip_readn             = serprog_chip_readn, 
     322                .chip_writeb            = serprog_chip_writeb, 
     323                .chip_writew            = fallback_chip_writew, 
     324                .chip_writel            = fallback_chip_writel, 
     325                .chip_writen            = fallback_chip_writen, 
     326}; 
     327 
     328static enum chipbustype serprog_buses_supported = BUS_NONE; 
     329 
    312330int serprog_init(void) 
    313331{ 
    … …  
    401419        if (sp_docommand(S_CMD_Q_IFACE, 0, NULL, 2, &iface)) { 
    402420                msg_perr("Error: NAK to query interface version\n"); 
    403                 exit(1); 
     421                return 1; 
    404422        } 
    405423 
    406424        if (iface != 1) { 
    407425                msg_perr("Error: Unknown interface version: %d\n", iface); 
    408                 exit(1); 
     426                return 1; 
    409427        } 
    410428 
    … …  
    413431        if (sp_docommand(S_CMD_Q_CMDMAP, 0, NULL, 32, sp_cmdmap)) { 
    414432                msg_perr("Error: query command map not supported\n"); 
    415                 exit(1); 
     433                return 1; 
    416434        } 
    417435 
    418436        sp_check_avail_automatic = 1; 
    419437 
    420  
     438        /* FIXME: This assumes that serprog device bustypes are always 
     439         * identical with flashrom bustype enums and that they all fit 
     440         * in a single byte. 
     441         */ 
    421442        if (sp_docommand(S_CMD_Q_BUSTYPE, 0, NULL, 1, &c)) { 
    422443                msg_perr("Warning: NAK to query supported buses\n"); 
    423444                c = BUS_NONSPI; /* A reasonable default for now. */ 
    424445        } 
    425         buses_supported = c; 
     446        serprog_buses_supported = c; 
     447 
    426448        msg_pdbg(MSGHEADER "Bus support: parallel=%s, LPC=%s, FWH=%s, SPI=%s\n", 
    427449                 (c & BUS_PARALLEL) ? "on" : "off", 
    … …  
    430452                 (c & BUS_SPI) ? "on" : "off"); 
    431453        /* Check for the minimum operational set of commands. */ 
    432         if (buses_supported & BUS_SPI) { 
     454        if (serprog_buses_supported & BUS_SPI) { 
    433455                uint8_t bt = BUS_SPI; 
    434456                if (sp_check_commandavail(S_CMD_O_SPIOP) == 0) { 
    435457                        msg_perr("Error: SPI operation not supported while the " 
    436458                                 "bustype is SPI\n"); 
    437                         exit(1); 
     459                        return 1; 
    438460                } 
    439461                /* Success of any of these commands is optional. We don't need 
    … …  
    462484                        msg_pdbg(MSGHEADER "Maximum read-n length is %d\n", v); 
    463485                } 
    464                 bt = buses_supported; 
     486                bt = serprog_buses_supported; 
    465487                sp_docommand(S_CMD_S_BUSTYPE, 1, &bt, 0, NULL); 
    466                 register_spi_programmer(&spi_programmer_serprog); 
    467         } 
    468  
    469         if (buses_supported & BUS_NONSPI) { 
     488        } 
     489 
     490        if (serprog_buses_supported & BUS_NONSPI) { 
    470491                if (sp_check_commandavail(S_CMD_O_INIT) == 0) { 
    471492                        msg_perr("Error: Initialize operation buffer " 
    472493                                 "not supported\n"); 
    473                         exit(1); 
     494                        return 1; 
    474495                } 
    475496 
    … …  
    477498                        msg_perr("Error: Write to opbuf: " 
    478499                                 "delay not supported\n"); 
    479                         exit(1); 
     500                        return 1; 
    480501                } 
    481502 
    … …  
    484505                if (sp_check_commandavail(S_CMD_R_BYTE) == 0) { 
    485506                        msg_perr("Error: Single byte read not supported\n"); 
    486                         exit(1); 
     507                        return 1; 
    487508                } 
    488509                /* This could be translated to single byte reads (if missing), 
    … …  
    490511                if (sp_check_commandavail(S_CMD_R_NBYTES) == 0) { 
    491512                        msg_perr("Error: Read n bytes not supported\n"); 
    492                         exit(1); 
     513                        return 1; 
    493514                } 
    494515                if (sp_check_commandavail(S_CMD_O_WRITEB) == 0) { 
    495516                        msg_perr("Error: Write to opbuf: " 
    496517                                 "write byte not supported\n"); 
    497                         exit(1); 
     518                        return 1; 
    498519                } 
    499520 
    … …  
    514535                                msg_perr("Error: cannot allocate memory for " 
    515536                                         "Write-n buffer\n"); 
    516                                 exit(1); 
     537                                return 1; 
    517538                        } 
    518539                        sp_write_n_bytes = 0; 
    … …  
    552573                        msg_perr("Error: Execute operation buffer not " 
    553574                                 "supported\n"); 
    554                         exit(1); 
     575                        return 1; 
    555576                } 
    556577 
    557578                if (sp_docommand(S_CMD_O_INIT, 0, NULL, 0, NULL)) { 
    558579                        msg_perr("Error: NAK to initialize operation buffer\n"); 
    559                         exit(1); 
     580                        return 1; 
    560581                } 
    561582 
    … …  
    573594        sp_streamed_transmit_bytes = 0; 
    574595        sp_opbuf_usage = 0; 
     596        if (serprog_buses_supported & BUS_SPI) 
     597                register_spi_programmer(&spi_programmer_serprog); 
     598        if (serprog_buses_supported & BUS_NONSPI) 
     599                register_par_programmer(&par_programmer_serprog, 
     600                                        serprog_buses_supported & BUS_NONSPI); 
    575601        return 0; 
    576602} 
    … …  
    767793} 
    768794 
    769 int serprog_spi_send_command(unsigned int writecnt, unsigned int readcnt, 
     795static int serprog_spi_send_command(unsigned int writecnt, unsigned int readcnt, 
    770796                             const unsigned char *writearr, 
    771797                             unsigned char *readarr) 
    … …  
    797823 * non-contiguous address space (like AT45DB161D). When spi_read_chunked is 
    798824 * fixed this method can be removed. */ 
    799 int serprog_spi_read(struct flashchip *flash, uint8_t *buf, int start, int len) 
     825static int serprog_spi_read(struct flashchip *flash, uint8_t *buf, int start, int len) 
    800826{ 
    801827        int i; 

  • trunk/wbsio_spi.c

    r1450 r1463  
    8383        msg_pspew("\nwbsio_spibase = 0x%x\n", wbsio_spibase); 
    8484 
    85         register_spi_programmer(&spi_programmer_wbsio); 
    8685        msg_pdbg("%s: Winbond saved on 4 register bits so max chip size is " 
    8786                 "1024 kB!\n", __func__); 
    8887        max_rom_decode.spi = 1024 * 1024; 
     88        register_spi_programmer(&spi_programmer_wbsio); 
    8989 
    9090        return 0; 
Note: See TracChangeset for help on using the changeset viewer.