| // SPDX-License-Identifier: GPL-2.0-or-later | |
| /* | |
| * eisa_enumerator.c - provide support for EISA adapters in PA-RISC machines | |
| * | |
| * Copyright (c) 2002 Daniel Engstrom <5116@telia.com> | |
| */ | |
| #include <linux/ioport.h> | |
| #include <linux/io.h> | |
| #include <linux/slab.h> | |
| #include <linux/unaligned.h> | |
| #include <asm/eisa_bus.h> | |
| #include <asm/eisa_eeprom.h> | |
| /* | |
| * TODO: | |
| * - PORT init with MASK attr and other size than byte | |
| * - MEMORY with other decode than 20 bit | |
| * - CRC stuff | |
| * - FREEFORM stuff | |
| */ | |
| #define EPI 0xc80 | |
| #define NUM_SLOT 16 | |
| #define SLOT2PORT(x) (x << 12) | |
| /* EEPROM data is little-endian, PA-RISC is big-endian. */ | |
| #define get_8(x) (*(u_int8_t *)(x)) | |
| #define get_16(x) get_unaligned_le16(x) | |
| #define get_32(x) get_unaligned_le32(x) | |
| #define get_24(x) (get_unaligned_le32(x) & 0x00ffffff) | |
| static void print_eisa_id(char *s, u_int32_t id) | |
| { | |
| char vendor[4]; | |
| int rev; | |
| int device; | |
| rev = id & 0xff; | |
| id >>= 8; | |
| device = id & 0xff; | |
| id >>= 8; | |
| vendor[3] = '\0'; | |
| vendor[2] = '@' + (id & 0x1f); | |
| id >>= 5; | |
| vendor[1] = '@' + (id & 0x1f); | |
| id >>= 5; | |
| vendor[0] = '@' + (id & 0x1f); | |
| id >>= 5; | |
| sprintf(s, "%s%02X%02X", vendor, device, rev); | |
| } | |
| static int configure_memory(const unsigned char *buf, | |
| struct resource *mem_parent, | |
| char *name) | |
| { | |
| int i, len = 0; | |
| for (i = 0; i < HPEE_MEMORY_MAX_ENT; i++) { | |
| struct resource *res; | |
| u_int8_t c = get_8(buf + len); | |
| if (NULL != (res = kzalloc_obj(struct resource))) { | |
| int result; | |
| res->name = name; | |
| res->start = mem_parent->start + get_24(buf + len + 2); | |
| res->end = res->start + get_16(buf + len + 5) * 1024; | |
| res->flags = IORESOURCE_MEM; | |
| pr_cont("memory %pR ", res); | |
| result = request_resource(mem_parent, res); | |
| if (result < 0) { | |
| pr_err("EISA Enumerator: failed to claim EISA Bus address space!\n"); | |
| return result; | |
| } | |
| } | |
| len += 7; | |
| if (!(c & HPEE_MEMORY_MORE)) | |
| break; | |
| } | |
| return len; | |
| } | |
| static int configure_irq(const unsigned char *buf) | |
| { | |
| int i, len = 0; | |
| for (i = 0; i < HPEE_IRQ_MAX_ENT; i++) { | |
| u_int8_t c = get_8(buf + len); | |
| pr_cont("IRQ %d ", c & HPEE_IRQ_CHANNEL_MASK); | |
| if (c & HPEE_IRQ_TRIG_LEVEL) { | |
| eisa_make_irq_level(c & HPEE_IRQ_CHANNEL_MASK); | |
| } else { | |
| eisa_make_irq_edge(c & HPEE_IRQ_CHANNEL_MASK); | |
| } | |
| len += 2; | |
| /* | |
| * HP-UX seems to allow for two bytes of irq data but | |
| * only defines one of them, I think | |
| */ | |
| if (!(c & HPEE_IRQ_MORE)) | |
| break; | |
| } | |
| return len; | |
| } | |
| static int configure_dma(const unsigned char *buf) | |
| { | |
| int i, len = 0; | |
| for (i = 0; i < HPEE_DMA_MAX_ENT; i++) { | |
| u_int8_t c = get_8(buf + len); | |
| pr_cont("DMA %d ", c&HPEE_DMA_CHANNEL_MASK); | |
| /* fixme: maybe initialize the dma channel withthe timing ? */ | |
| len += 2; | |
| if (!(c & HPEE_DMA_MORE)) | |
| break; | |
| } | |
| return len; | |
| } | |
| static int configure_port(const unsigned char *buf, struct resource *io_parent, | |
| char *board) | |
| { | |
| int i, result, len = 0; | |
| for (i = 0; i < HPEE_PORT_MAX_ENT; i++) { | |
| struct resource *res; | |
| u_int8_t c = get_8(buf + len); | |
| if (NULL != (res = kzalloc_obj(struct resource))) { | |
| res->name = board; | |
| res->start = get_16(buf + len + 1); | |
| res->end = res->start + (c & HPEE_PORT_SIZE_MASK) + 1; | |
| res->flags = IORESOURCE_IO; | |
| pr_cont("ioports %pR ", res); | |
| result = request_resource(io_parent, res); | |
| if (result < 0) { | |
| pr_err("EISA Enumerator: failed to claim EISA Bus address space!\n"); | |
| return result; | |
| } | |
| } | |
| len += 3; | |
| if (!(c & HPEE_PORT_MORE)) | |
| break; | |
| } | |
| return len; | |
| } | |
| /* | |
| * Byte 1 and 2 is the port number to write and at byte 3 the value to write | |
| * starts. I assume that there are and- and or- masks here when | |
| * HPEE_PORT_INIT_MASK is set but I have not yet encountered this. | |
| */ | |
| static int configure_port_init(const unsigned char *buf) | |
| { | |
| int len = 0; | |
| while (len < HPEE_PORT_INIT_MAX_LEN) { | |
| int s = 0; | |
| u_int8_t c = get_8(buf + len); | |
| switch (c & HPEE_PORT_INIT_WIDTH_MASK) { | |
| case HPEE_PORT_INIT_WIDTH_BYTE: | |
| s = 1; | |
| if (c & HPEE_PORT_INIT_MASK) { | |
| pr_warn("port_init: unverified mask attribute\n"); | |
| outb((inb(get_16(buf + len + 1) & | |
| get_8(buf + len + 3)) | | |
| get_8(buf + len + 4)), | |
| get_16(buf + len + 1)); | |
| } else { | |
| outb(get_8(buf + len + 3), | |
| get_16(buf + len + 1)); | |
| } | |
| break; | |
| case HPEE_PORT_INIT_WIDTH_WORD: | |
| s = 2; | |
| if (c & HPEE_PORT_INIT_MASK) { | |
| pr_warn("port_init: unverified mask attribute\n"); | |
| outw((inw(get_16(buf + len + 1)) & | |
| get_16(buf + len + 3)) | | |
| get_16(buf + len + 5), | |
| get_16(buf + len + 1)); | |
| } else { | |
| outw(cpu_to_le16(get_16(buf + len + 3)), | |
| get_16(buf + len + 1)); | |
| } | |
| break; | |
| case HPEE_PORT_INIT_WIDTH_DWORD: | |
| s = 4; | |
| if (c & HPEE_PORT_INIT_MASK) { | |
| pr_warn("port_init: unverified mask attribute\n"); | |
| outl((inl(get_16(buf + len + 1) & | |
| get_32(buf + len + 3)) | | |
| get_32(buf + len + 7)), get_16(buf + len + 1)); | |
| } else { | |
| outl(cpu_to_le32(get_32(buf + len + 3)), | |
| get_16(buf + len + 1)); | |
| } | |
| break; | |
| default: | |
| pr_warn("Invalid port init word %02x\n", c); | |
| return 0; | |
| } | |
| if (c & HPEE_PORT_INIT_MASK) | |
| s *= 2; | |
| len += s + 3; | |
| if (!(c & HPEE_PORT_INIT_MORE)) | |
| break; | |
| } | |
| return len; | |
| } | |
| static int configure_choise(const unsigned char *buf, u_int8_t *info) | |
| { | |
| int len; | |
| /* | |
| * This record contain the value of the functions configuration | |
| * chooses and an info byte which describes which other records to | |
| * expect in this function. | |
| */ | |
| len = get_8(buf); | |
| *info = get_8(buf + len + 1); | |
| return len + 2; | |
| } | |
| static int configure_type_string(const unsigned char *buf) | |
| { | |
| int len; | |
| /* just skip past the type field */ | |
| len = get_8(buf); | |
| if (len > 80) { | |
| pr_err("eisa_enumerator: type info field too long (%d, max is 80)\n", len); | |
| } | |
| return 1 + len; | |
| } | |
| static int configure_function(const unsigned char *buf, int *more) | |
| { | |
| /* the init field seems to be a two-byte field | |
| * which is non-zero if there are an other function following | |
| * I think it is the length of the function def | |
| */ | |
| *more = get_16(buf); | |
| return 2; | |
| } | |
| static int parse_slot_config(int slot, | |
| const unsigned char *buf, | |
| unsigned int buflen, | |
| struct eeprom_eisa_slot_info *es, | |
| struct resource *io_parent, | |
| struct resource *mem_parent) | |
| { | |
| int res = 0; | |
| int function_len; | |
| unsigned int pos = 0; | |
| unsigned int maxlen; | |
| int num_func = 0; | |
| u_int8_t flags; | |
| int p0; | |
| char *board; | |
| int id_string_used = 0; | |
| if (NULL == (board = kmalloc(8, GFP_KERNEL))) { | |
| return -1; | |
| } | |
| print_eisa_id(board, es->eisa_slot_id); | |
| pr_info("EISA slot %d: %s %s ", | |
| slot, board, es->flags&HPEE_FLAG_BOARD_IS_ISA ? "ISA" : "EISA"); | |
| /* never parse beyond the data that is actually in the buffer */ | |
| maxlen = min_t(unsigned int, es->config_data_length, buflen); | |
| while ((pos < maxlen) && (num_func <= es->num_functions)) { | |
| pos += configure_function(buf + pos, &function_len); | |
| if (!function_len) | |
| break; | |
| num_func++; | |
| p0 = pos; | |
| pos += configure_choise(buf+pos, &flags); | |
| if (flags & HPEE_FUNCTION_INFO_F_DISABLED) { | |
| /* function disabled, skip silently */ | |
| pos = p0 + function_len; | |
| continue; | |
| } | |
| if (flags & HPEE_FUNCTION_INFO_CFG_FREE_FORM) { | |
| /* I have no idea how to handle this */ | |
| pr_err("function %d have free-form configuration, skipping ", | |
| num_func); | |
| pos = p0 + function_len; | |
| continue; | |
| } | |
| /* the ordering of the sections need more investigation. | |
| * Currently I think that memory command before IRQ | |
| * I assume the order is LSB to MSB in the info flags | |
| * eg type, memory, irq, dma, port, HPEE_PORT_init | |
| */ | |
| if (flags & HPEE_FUNCTION_INFO_HAVE_TYPE) { | |
| pos += configure_type_string(buf + pos); | |
| } | |
| if (flags & HPEE_FUNCTION_INFO_HAVE_MEMORY) { | |
| id_string_used = 1; | |
| pos += configure_memory(buf + pos, mem_parent, board); | |
| } | |
| if (flags & HPEE_FUNCTION_INFO_HAVE_IRQ) { | |
| pos += configure_irq(buf + pos); | |
| } | |
| if (flags & HPEE_FUNCTION_INFO_HAVE_DMA) { | |
| pos += configure_dma(buf + pos); | |
| } | |
| if (flags & HPEE_FUNCTION_INFO_HAVE_PORT) { | |
| id_string_used = 1; | |
| pos += configure_port(buf + pos, io_parent, board); | |
| } | |
| if (flags & HPEE_FUNCTION_INFO_HAVE_PORT_INIT) { | |
| pos += configure_port_init(buf + pos); | |
| } | |
| if (p0 + function_len < pos) { | |
| pr_err("eisa_enumerator: function %d length mismatch " | |
| "got %d, expected %d\n", | |
| num_func, pos - p0, function_len); | |
| res = -1; | |
| break; | |
| } | |
| pos = p0 + function_len; | |
| } | |
| pr_cont("\n"); | |
| if (!id_string_used) { | |
| kfree(board); | |
| } | |
| if (pos != es->config_data_length) { | |
| pr_err("eisa_enumerator: config data length mismatch got %d, expected %d\n", | |
| pos, es->config_data_length); | |
| res = -1; | |
| } | |
| if (num_func != es->num_functions) { | |
| pr_err("eisa_enumerator: number of functions mismatch got %d, expected %d\n", | |
| num_func, es->num_functions); | |
| res = -2; | |
| } | |
| return res; | |
| } | |
| static int init_slot(int slot, struct eeprom_eisa_slot_info *es) | |
| { | |
| unsigned int id; | |
| char id_string[8], id_string2[8]; | |
| if (!(es->slot_info & HPEE_SLOT_INFO_NO_READID)) { | |
| /* try to read the id of the board in the slot */ | |
| id = le32_to_cpu(inl(SLOT2PORT(slot) + EPI)); | |
| if (0xffffffff == id) { | |
| /* Maybe we didn't expect a card to be here... */ | |
| if (es->eisa_slot_id == 0xffffffff) | |
| return -1; | |
| /* board is not here or it does not support readid */ | |
| print_eisa_id(id_string, es->eisa_slot_id); | |
| pr_err("EISA slot %d a configured board was not detected (expected %s)\n", | |
| slot, id_string); | |
| return -1; | |
| } | |
| if (es->eisa_slot_id != id) { | |
| print_eisa_id(id_string, id); | |
| print_eisa_id(id_string2, es->eisa_slot_id); | |
| pr_err("EISA slot %d id mismatch: got %s expected %s\n", | |
| slot, id_string, id_string2); | |
| return -1; | |
| } | |
| } | |
| /* now: we need to enable the board if | |
| * it supports enabling and run through | |
| * the port init sction if present | |
| * and finally record any interrupt polarity | |
| */ | |
| if (es->slot_features & HPEE_SLOT_FEATURES_ENABLE) { | |
| /* enable board */ | |
| outb(0x01 | inb(SLOT2PORT(slot) + EPI + 4), | |
| SLOT2PORT(slot) + EPI + 4); | |
| } | |
| return 0; | |
| } | |
| int eisa_enumerator(unsigned long eeprom_addr, | |
| struct resource *io_parent, struct resource *mem_parent) | |
| { | |
| int i; | |
| struct eeprom_header *eh; | |
| static char eeprom_buf[HPEE_MAX_LENGTH]; | |
| for (i = 0; i < HPEE_MAX_LENGTH; i++) | |
| eeprom_buf[i] = gsc_readb(eeprom_addr + i); | |
| pr_info("Enumerating EISA bus\n"); | |
| eh = (struct eeprom_header*)(eeprom_buf); | |
| /* | |
| * The EEPROM contents are not to be trusted: clamp the number of | |
| * slots so that all slot records fit into eeprom_buf. | |
| */ | |
| eh->num_slots = min_t(u8, eh->num_slots, | |
| (HPEE_MAX_LENGTH - sizeof(*eh)) / | |
| sizeof(struct eeprom_eisa_slot_info)); | |
| for (i = 0; i < eh->num_slots; i++) { | |
| struct eeprom_eisa_slot_info *es; | |
| es = (struct eeprom_eisa_slot_info*) | |
| (&eeprom_buf[HPEE_SLOT_INFO(i)]); | |
| if (-1 == init_slot(i + 1, es)) | |
| continue; | |
| if (es->config_data_offset < HPEE_MAX_LENGTH) { | |
| if (parse_slot_config(i + 1, &eeprom_buf[es->config_data_offset], | |
| HPEE_MAX_LENGTH - es->config_data_offset, | |
| es, io_parent, mem_parent)) { | |
| return -1; | |
| } | |
| } else { | |
| pr_err("EISA EEPROM offset 0x%x out of range\n", | |
| es->config_data_offset); | |
| return -1; | |
| } | |
| } | |
| return eh->num_slots; | |
| } |