Techwizz/kernel-fxtec-pro1x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

m68k updates for 4.12

Browse source 
- More kernel message modernizations and cleanups,
   - Mac and Nubus improvements and cleanups.
 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1
 
 iQIcBAABAgAGBQJZCDNZAAoJEEgEtLw/Ve77Y9MP/iCxkwSnVy1yv8+abAOwboh5
 hK+M4S+7t0tcxq1dzneKG9ZiT6Qd9VB5FF0Pxz2sB4U83mTvhCHdvrFDpSPFXCqN
 Wr5xuRVXQfrIE1S3oxi1f/nsT7FFeEY4SSG8tZL1Cyd4jpVYdUkzUMhTyJ3x03ri
 3nDAtBn34r4XYRXj0rNXOgwnCRTrJMG5AO4MnnWJcpBh1azlvU/rJ8MNoN3CpOk8
 RWbOoLSYxxLXmdXbackhYhuqXtvN3djqKgPhjDUlH807jP9PRdLQYFLekwpQZfRl
 1a6trDNRCUzOnjsinukPvMg50EJnhNzlxSCw9YG/F+pexiDrnu2t+W9GHUcNYQhZ
 acqteY0f8hOSEmQMRYUPFcI2hkdeH2Z2y3rkWNsNdJV56ukiF8Qbzqz42aX6RD4s
 GuprHKkV2BdXF3IPdsbXFscThnSNFJCjKyWTDtgsQRAFs2vkSyeAGgzHI9W4jgVB
 9ZVDhCFNXmZrWAmAnnAXzfWwTS5dYnjdLpkPHnXM38gQ8zOVj1ZFvXpRD77RH7Fb
 sSCS6HLywJws3S+W4Jngl9M3JZ9Mk0inYk+7CqTqL3nBRy6eFwcpVv1ExH4Aoeg7
 BDDMyBNaE/mtNGErt+s6yLA8PwslKoDzQfbxJdzazJ5CHKL8A4FiUzF9UlQ5Gm1b
 zsAkSKkeHy8NG/AVJ2J/
 =IbyF
 -----END PGP SIGNATURE-----

Merge tag 'm68k-for-v4.12-tag1' of git://git.kernel.org/pub/scm/linux/kernel/git/geert/linux-m68k

Pull m68k updates from Geert Uytterhoeven:

  - more kernel message modernizations and cleanups

  - Mac and Nubus improvements and cleanups.

* tag 'm68k-for-v4.12-tag1' of git://git.kernel.org/pub/scm/linux/kernel/git/geert/linux-m68k:
  nubus: Add MVC and VSC video card definitions
  nubus: Clean up whitespace
  nubus: Clean up printk calls
  nubus: Fix nubus_rewinddir
  m68k/mac: Clarify IOP message alloc/free confusion
  m68k/mac: Adopt platform_device_register_simple()
  m68k/mac: Modernize printing of kernel messages
  m68k/mac: IOP - Modernize printing of kernel messages
This commit is contained in:
Linus Torvalds 2017-05-02 10:10:52 -07:00
commit ceb198bb00
5 changed files with 279 additions and 363 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

61
arch/m68k/mac/config.c
View file

@ -150,7 +150,7 @@ static void mac_cache_card_flush(int writeback)
void __init config_mac(void) void __init config_mac(void)
{ {
if (!MACH_IS_MAC) if (!MACH_IS_MAC)
printk(KERN_ERR "ERROR: no Mac, but config_mac() called!!\n"); pr_err("ERROR: no Mac, but config_mac() called!!\n");
mach_sched_init = mac_sched_init; mach_sched_init = mac_sched_init;
mach_init_IRQ = mac_init_IRQ; mach_init_IRQ = mac_init_IRQ;
@ -837,8 +837,7 @@ static void __init mac_identify(void)
/* no bootinfo model id -> NetBSD booter was used! */ /* no bootinfo model id -> NetBSD booter was used! */
/* XXX FIXME: breaks for model > 31 */ /* XXX FIXME: breaks for model > 31 */
model = (mac_bi_data.cpuid >> 2) & 63; model = (mac_bi_data.cpuid >> 2) & 63;
printk(KERN_WARNING "No bootinfo model ID, using cpuid instead " pr_warn("No bootinfo model ID, using cpuid instead (obsolete bootloader?)\n");
"(obsolete bootloader?)\n");
} }
macintosh_config = mac_data_table; macintosh_config = mac_data_table;
@ -880,14 +879,13 @@ static void __init mac_identify(void)
*/ */
iop_preinit(); iop_preinit();
printk(KERN_INFO "Detected Macintosh model: %d\n", model); pr_info("Detected Macintosh model: %d\n", model);
/* /*
* Report booter data: * Report booter data:
*/ */
printk(KERN_DEBUG " Penguin bootinfo data:\n"); printk(KERN_DEBUG " Penguin bootinfo data:\n");
printk(KERN_DEBUG " Video: addr 0x%lx " printk(KERN_DEBUG " Video: addr 0x%lx row 0x%lx depth %lx dimensions %ld x %ld\n",
"row 0x%lx depth %lx dimensions %ld x %ld\n",
mac_bi_data.videoaddr, mac_bi_data.videorow, mac_bi_data.videoaddr, mac_bi_data.videorow,
mac_bi_data.videodepth, mac_bi_data.dimensions & 0xFFFF, mac_bi_data.videodepth, mac_bi_data.dimensions & 0xFFFF,
mac_bi_data.dimensions >> 16); mac_bi_data.dimensions >> 16);
@ -912,7 +910,7 @@ static void __init mac_identify(void)
static void __init mac_report_hardware(void) static void __init mac_report_hardware(void)
{ {
printk(KERN_INFO "Apple Macintosh %s\n", macintosh_config->name); pr_info("Apple Macintosh %s\n", macintosh_config->name);
} }
static void mac_get_model(char *str) static void mac_get_model(char *str)
@ -921,15 +919,6 @@ static void mac_get_model(char *str)
strcat(str, macintosh_config->name); strcat(str, macintosh_config->name);
} }
static struct resource swim_rsrc = { .flags = IORESOURCE_MEM };
static struct platform_device swim_pdev = {
.name = "swim",
.id = -1,
.num_resources = 1,
.resource = &swim_rsrc,
};
static const struct resource mac_scsi_iifx_rsrc[] __initconst = { static const struct resource mac_scsi_iifx_rsrc[] __initconst = {
{ {
.flags = IORESOURCE_IRQ, .flags = IORESOURCE_IRQ,
@ -994,26 +983,6 @@ static const struct resource mac_scsi_ccl_rsrc[] __initconst = {
}, },
}; };
static struct platform_device esp_0_pdev = {
.name = "mac_esp",
.id = 0,
};
static struct platform_device esp_1_pdev = {
.name = "mac_esp",
.id = 1,
};
static struct platform_device sonic_pdev = {
.name = "macsonic",
.id = -1,
};
static struct platform_device mace_pdev = {
.name = "macmace",
.id = -1,
};
int __init mac_platform_init(void) int __init mac_platform_init(void)
{ {
u8 *swim_base; u8 *swim_base;
@ -1045,9 +1014,13 @@ int __init mac_platform_init(void)
} }
if (swim_base) { if (swim_base) {
swim_rsrc.start = (resource_size_t) swim_base, struct resource swim_rsrc = {
swim_rsrc.end = (resource_size_t) swim_base + 0x2000, .flags = IORESOURCE_MEM,
platform_device_register(&swim_pdev); .start = (resource_size_t)swim_base,
.end = (resource_size_t)swim_base + 0x2000,
};
platform_device_register_simple("swim", -1, &swim_rsrc, 1);
} }
/* /*
@ -1057,13 +1030,13 @@ int __init mac_platform_init(void)
switch (macintosh_config->scsi_type) { switch (macintosh_config->scsi_type) {
case MAC_SCSI_QUADRA: case MAC_SCSI_QUADRA:
case MAC_SCSI_QUADRA3: case MAC_SCSI_QUADRA3:
platform_device_register(&esp_0_pdev); platform_device_register_simple("mac_esp", 0, NULL, 0);
break; break;
case MAC_SCSI_QUADRA2: case MAC_SCSI_QUADRA2:
platform_device_register(&esp_0_pdev); platform_device_register_simple("mac_esp", 0, NULL, 0);
if ((macintosh_config->ident == MAC_MODEL_Q900) || if ((macintosh_config->ident == MAC_MODEL_Q900) ||
(macintosh_config->ident == MAC_MODEL_Q950)) (macintosh_config->ident == MAC_MODEL_Q950))
platform_device_register(&esp_1_pdev); platform_device_register_simple("mac_esp", 1, NULL, 0);
break; break;
case MAC_SCSI_IIFX: case MAC_SCSI_IIFX:
/* Addresses from The Guide to Mac Family Hardware. /* Addresses from The Guide to Mac Family Hardware.
@ -1129,10 +1102,10 @@ int __init mac_platform_init(void)
switch (macintosh_config->ether_type) { switch (macintosh_config->ether_type) {
case MAC_ETHER_SONIC: case MAC_ETHER_SONIC:
platform_device_register(&sonic_pdev); platform_device_register_simple("macsonic", -1, NULL, 0);
break; break;
case MAC_ETHER_MACE: case MAC_ETHER_MACE:
platform_device_register(&mace_pdev); platform_device_register_simple("macmace", -1, NULL, 0);
break; break;
} }

93
arch/m68k/mac/iop.c
View file

@ -115,7 +115,17 @@
#include <asm/macints.h> #include <asm/macints.h>
#include <asm/mac_iop.h> #include <asm/mac_iop.h>
/*#define DEBUG_IOP*/ #ifdef DEBUG
#define iop_pr_debug(fmt, ...) \
printk(KERN_DEBUG "%s: " fmt, __func__, ##__VA_ARGS__)
#define iop_pr_cont(fmt, ...) \
printk(KERN_CONT fmt, ##__VA_ARGS__)
#else
#define iop_pr_debug(fmt, ...) \
no_printk(KERN_DEBUG "%s: " fmt, __func__, ##__VA_ARGS__)
#define iop_pr_cont(fmt, ...) \
no_printk(KERN_CONT fmt, ##__VA_ARGS__)
#endif
/* Non-zero if the IOPs are present */ /* Non-zero if the IOPs are present */
@ -200,7 +210,7 @@ static int iop_alive(volatile struct mac_iop *iop)
return retval; return retval;
} }
static struct iop_msg *iop_alloc_msg(void) static struct iop_msg *iop_get_unused_msg(void)
{ {
int i; int i;
unsigned long flags; unsigned long flags;
@ -219,11 +229,6 @@ static struct iop_msg *iop_alloc_msg(void)
return NULL; return NULL;
} }
static void iop_free_msg(struct iop_msg *msg)
{
msg->status = IOP_MSGSTATUS_UNUSED;
}
/* /*
* This is called by the startup code before anything else. Its purpose * This is called by the startup code before anything else. Its purpose
* is to find and initialize the IOPs early in the boot sequence, so that * is to find and initialize the IOPs early in the boot sequence, so that
@ -268,10 +273,10 @@ void __init iop_init(void)
int i; int i;
if (iop_scc_present) { if (iop_scc_present) {
printk("IOP: detected SCC IOP at %p\n", iop_base[IOP_NUM_SCC]); pr_info("IOP: detected SCC IOP at %p\n", iop_base[IOP_NUM_SCC]);
} }
if (iop_ism_present) { if (iop_ism_present) {
printk("IOP: detected ISM IOP at %p\n", iop_base[IOP_NUM_ISM]); pr_info("IOP: detected ISM IOP at %p\n", iop_base[IOP_NUM_ISM]);
iop_start(iop_base[IOP_NUM_ISM]); iop_start(iop_base[IOP_NUM_ISM]);
iop_alive(iop_base[IOP_NUM_ISM]); /* clears the alive flag */ iop_alive(iop_base[IOP_NUM_ISM]); /* clears the alive flag */
} }
@ -310,9 +315,9 @@ void __init iop_register_interrupts(void)
pr_err("Couldn't register ISM IOP interrupt\n"); pr_err("Couldn't register ISM IOP interrupt\n");
} }
if (!iop_alive(iop_base[IOP_NUM_ISM])) { if (!iop_alive(iop_base[IOP_NUM_ISM])) {
printk("IOP: oh my god, they killed the ISM IOP!\n"); pr_warn("IOP: oh my god, they killed the ISM IOP!\n");
} else { } else {
printk("IOP: the ISM IOP seems to be alive.\n"); pr_warn("IOP: the ISM IOP seems to be alive.\n");
} }
} }
} }
@ -349,9 +354,8 @@ void iop_complete_message(struct iop_msg *msg)
int chan = msg->channel; int chan = msg->channel;
int i,offset; int i,offset;
#ifdef DEBUG_IOP iop_pr_debug("msg %p iop_num %d channel %d\n", msg, msg->iop_num,
printk("iop_complete(%p): iop %d chan %d\n", msg, msg->iop_num, msg->channel); msg->channel);
#endif
offset = IOP_ADDR_RECV_MSG + (msg->channel * IOP_MSG_LEN); offset = IOP_ADDR_RECV_MSG + (msg->channel * IOP_MSG_LEN);
@ -363,7 +367,7 @@ void iop_complete_message(struct iop_msg *msg)
IOP_ADDR_RECV_STATE + chan, IOP_MSG_COMPLETE); IOP_ADDR_RECV_STATE + chan, IOP_MSG_COMPLETE);
iop_interrupt(iop_base[msg->iop_num]); iop_interrupt(iop_base[msg->iop_num]);
iop_free_msg(msg); msg->status = IOP_MSGSTATUS_UNUSED;
} }
/* /*
@ -394,12 +398,10 @@ static void iop_do_send(struct iop_msg *msg)
static void iop_handle_send(uint iop_num, uint chan) static void iop_handle_send(uint iop_num, uint chan)
{ {
volatile struct mac_iop *iop = iop_base[iop_num]; volatile struct mac_iop *iop = iop_base[iop_num];
struct iop_msg *msg,*msg2; struct iop_msg *msg;
int i,offset; int i,offset;
#ifdef DEBUG_IOP iop_pr_debug("iop_num %d chan %d\n", iop_num, chan);
printk("iop_handle_send: iop %d channel %d\n", iop_num, chan);
#endif
iop_writeb(iop, IOP_ADDR_SEND_STATE + chan, IOP_MSG_IDLE); iop_writeb(iop, IOP_ADDR_SEND_STATE + chan, IOP_MSG_IDLE);
@ -411,10 +413,8 @@ static void iop_handle_send(uint iop_num, uint chan)
msg->reply[i] = iop_readb(iop, offset); msg->reply[i] = iop_readb(iop, offset);
} }
if (msg->handler) (*msg->handler)(msg); if (msg->handler) (*msg->handler)(msg);
msg2 = msg; msg->status = IOP_MSGSTATUS_UNUSED;
msg = msg->next; msg = msg->next;
iop_free_msg(msg2);
iop_send_queue[iop_num][chan] = msg; iop_send_queue[iop_num][chan] = msg;
if (msg) iop_do_send(msg); if (msg) iop_do_send(msg);
} }
@ -430,11 +430,9 @@ static void iop_handle_recv(uint iop_num, uint chan)
int i,offset; int i,offset;
struct iop_msg *msg; struct iop_msg *msg;
#ifdef DEBUG_IOP iop_pr_debug("iop_num %d chan %d\n", iop_num, chan);
printk("iop_handle_recv: iop %d channel %d\n", iop_num, chan);
#endif
msg = iop_alloc_msg(); msg = iop_get_unused_msg();
msg->iop_num = iop_num; msg->iop_num = iop_num;
msg->channel = chan; msg->channel = chan;
msg->status = IOP_MSGSTATUS_UNSOL; msg->status = IOP_MSGSTATUS_UNSOL;
@ -454,14 +452,9 @@ static void iop_handle_recv(uint iop_num, uint chan)
if (msg->handler) { if (msg->handler) {
(*msg->handler)(msg); (*msg->handler)(msg);
} else { } else {
#ifdef DEBUG_IOP iop_pr_debug("unclaimed message on iop_num %d chan %d\n",
printk("iop_handle_recv: unclaimed message on iop %d channel %d\n", iop_num, chan); iop_num, chan);
printk("iop_handle_recv:"); iop_pr_debug("%*ph\n", IOP_MSG_LEN, msg->message);
for (i = 0 ; i < IOP_MSG_LEN ; i++) {
printk(" %02X", (uint) msg->message[i]);
}
printk("\n");
#endif
iop_complete_message(msg); iop_complete_message(msg);
} }
} }
@ -484,7 +477,7 @@ int iop_send_message(uint iop_num, uint chan, void *privdata,
if (chan >= NUM_IOP_CHAN) return -EINVAL; if (chan >= NUM_IOP_CHAN) return -EINVAL;
if (msg_len > IOP_MSG_LEN) return -EINVAL; if (msg_len > IOP_MSG_LEN) return -EINVAL;
msg = iop_alloc_msg(); msg = iop_get_unused_msg();
if (!msg) return -ENOMEM; if (!msg) return -ENOMEM;
msg->next = NULL; msg->next = NULL;
@ -574,50 +567,34 @@ irqreturn_t iop_ism_irq(int irq, void *dev_id)
volatile struct mac_iop *iop = iop_base[iop_num]; volatile struct mac_iop *iop = iop_base[iop_num];
int i,state; int i,state;
#ifdef DEBUG_IOP iop_pr_debug("status %02X\n", iop->status_ctrl);
printk("iop_ism_irq: status = %02X\n", (uint) iop->status_ctrl);
#endif
/* INT0 indicates a state change on an outgoing message channel */ /* INT0 indicates a state change on an outgoing message channel */
if (iop->status_ctrl & IOP_INT0) { if (iop->status_ctrl & IOP_INT0) {
iop->status_ctrl = IOP_INT0 | IOP_RUN | IOP_AUTOINC; iop->status_ctrl = IOP_INT0 | IOP_RUN | IOP_AUTOINC;
#ifdef DEBUG_IOP iop_pr_debug("new status %02X, send states", iop->status_ctrl);
printk("iop_ism_irq: new status = %02X, send states",
(uint) iop->status_ctrl);
#endif
for (i = 0 ; i < NUM_IOP_CHAN ; i++) { for (i = 0 ; i < NUM_IOP_CHAN ; i++) {
state = iop_readb(iop, IOP_ADDR_SEND_STATE + i); state = iop_readb(iop, IOP_ADDR_SEND_STATE + i);
#ifdef DEBUG_IOP iop_pr_cont(" %02X", state);
printk(" %02X", state);
#endif
if (state == IOP_MSG_COMPLETE) { if (state == IOP_MSG_COMPLETE) {
iop_handle_send(iop_num, i); iop_handle_send(iop_num, i);
} }
} }
#ifdef DEBUG_IOP iop_pr_cont("\n");
printk("\n");
#endif
} }
if (iop->status_ctrl & IOP_INT1) { /* INT1 for incoming msgs */ if (iop->status_ctrl & IOP_INT1) { /* INT1 for incoming msgs */
iop->status_ctrl = IOP_INT1 | IOP_RUN | IOP_AUTOINC; iop->status_ctrl = IOP_INT1 | IOP_RUN | IOP_AUTOINC;
#ifdef DEBUG_IOP iop_pr_debug("new status %02X, recv states", iop->status_ctrl);
printk("iop_ism_irq: new status = %02X, recv states",
(uint) iop->status_ctrl);
#endif
for (i = 0 ; i < NUM_IOP_CHAN ; i++) { for (i = 0 ; i < NUM_IOP_CHAN ; i++) {
state = iop_readb(iop, IOP_ADDR_RECV_STATE + i); state = iop_readb(iop, IOP_ADDR_RECV_STATE + i);
#ifdef DEBUG_IOP iop_pr_cont(" %02X", state);
printk(" %02X", state);
#endif
if (state == IOP_MSG_NEW) { if (state == IOP_MSG_NEW) {
iop_handle_recv(iop_num, i); iop_handle_recv(iop_num, i);
} }
} }
#ifdef DEBUG_IOP iop_pr_cont("\n");
printk("\n");
#endif
} }
return IRQ_HANDLED; return IRQ_HANDLED;
} }

23
arch/m68k/mac/misc.c
View file

@ -281,8 +281,7 @@ static long via_read_time(void)
last_result.idata = result.idata; last_result.idata = result.idata;
} }
pr_err("via_read_time: failed to read a stable value; " pr_err("via_read_time: failed to read a stable value; got 0x%08lx then 0x%08lx\n",
"got 0x%08lx then 0x%08lx\n",
last_result.idata, result.idata); last_result.idata, result.idata);
return 0; return 0;
@ -465,7 +464,7 @@ void mac_poweroff(void)
#endif #endif
} }
local_irq_enable(); local_irq_enable();
printk("It is now safe to turn off your Macintosh.\n"); pr_crit("It is now safe to turn off your Macintosh.\n");
while(1); while(1);
} }
@ -556,7 +555,7 @@ void mac_reset(void)
/* should never get here */ /* should never get here */
local_irq_enable(); local_irq_enable();
printk ("Restart failed. Please restart manually.\n"); pr_crit("Restart failed. Please restart manually.\n");
while(1); while(1);
} }
@ -661,17 +660,13 @@ int mac_hwclk(int op, struct rtc_time *t)
unmktime(now, 0, unmktime(now, 0,
&t->tm_year, &t->tm_mon, &t->tm_mday, &t->tm_year, &t->tm_mon, &t->tm_mday,
&t->tm_hour, &t->tm_min, &t->tm_sec); &t->tm_hour, &t->tm_min, &t->tm_sec);
#if 0 pr_debug("%s: read %04d-%02d-%-2d %02d:%02d:%02d\n",
printk("mac_hwclk: read %04d-%02d-%-2d %02d:%02d:%02d\n", __func__, t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);
t->tm_hour, t->tm_min, t->tm_sec);
#endif
} else { /* write */ } else { /* write */
#if 0 pr_debug("%s: tried to write %04d-%02d-%-2d %02d:%02d:%02d\n",
printk("mac_hwclk: tried to write %04d-%02d-%-2d %02d:%02d:%02d\n", __func__, t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);
t->tm_hour, t->tm_min, t->tm_sec);
#endif
now = mktime(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, now = mktime(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
t->tm_hour, t->tm_min, t->tm_sec); t->tm_hour, t->tm_min, t->tm_sec);

461
drivers/nubus/nubus.c
View file

@ -44,8 +44,8 @@ extern void oss_nubus_init(void);
/* Globals */ /* Globals */
struct nubus_dev* nubus_devices; struct nubus_dev *nubus_devices;
struct nubus_board* nubus_boards; struct nubus_board *nubus_boards;
/* Meaning of "bytelanes": /* Meaning of "bytelanes":
@ -69,26 +69,26 @@ struct nubus_board* nubus_boards;
Etcetera, etcetera. Hopefully this clears up some confusion over Etcetera, etcetera. Hopefully this clears up some confusion over
what the following code actually does. */ what the following code actually does. */
static inline int not_useful(void *p, int map) static inline int not_useful(void *p, int map)
{ {
unsigned long pv=(unsigned long)p; unsigned long pv = (unsigned long)p;
pv &= 3; pv &= 3;
if(map & (1<<pv)) if (map & (1 << pv))
return 0; return 0;
return 1; return 1;
} }
static unsigned long nubus_get_rom(unsigned char **ptr, int len, int map) static unsigned long nubus_get_rom(unsigned char **ptr, int len, int map)
{ {
/* This will hold the result */ /* This will hold the result */
unsigned long v = 0; unsigned long v = 0;
unsigned char *p = *ptr; unsigned char *p = *ptr;
while(len) while (len) {
{
v <<= 8; v <<= 8;
while(not_useful(p,map)) while (not_useful(p, map))
p++; p++;
v |= *p++; v |= *p++;
len--; len--;
@ -99,31 +99,28 @@ static unsigned long nubus_get_rom(unsigned char **ptr, int len, int map)
static void nubus_rewind(unsigned char **ptr, int len, int map) static void nubus_rewind(unsigned char **ptr, int len, int map)
{ {
unsigned char *p=*ptr; unsigned char *p = *ptr;
/* Sanity check */ /* Sanity check */
if(len > 65536) if (len > 65536)
printk(KERN_ERR "rewind of 0x%08x!\n", len); pr_err("rewind of 0x%08x!\n", len);
while(len) while (len) {
{ do {
do
{
p--; p--;
} } while (not_useful(p, map));
while(not_useful(p, map));
len--; len--;
} }
*ptr=p; *ptr = p;
} }
static void nubus_advance(unsigned char **ptr, int len, int map) static void nubus_advance(unsigned char **ptr, int len, int map)
{ {
unsigned char *p = *ptr; unsigned char *p = *ptr;
if(len>65536)
printk(KERN_ERR "advance of 0x%08x!\n", len); if (len > 65536)
while(len) pr_err("advance of 0x%08x!\n", len);
{ while (len) {
while(not_useful(p,map)) while (not_useful(p, map))
p++; p++;
p++; p++;
len--; len--;
@ -133,9 +130,9 @@ static void nubus_advance(unsigned char **ptr, int len, int map)
static void nubus_move(unsigned char **ptr, int len, int map) static void nubus_move(unsigned char **ptr, int len, int map)
{ {
if(len > 0) if (len > 0)
nubus_advance(ptr, len, map); nubus_advance(ptr, len, map);
else if(len < 0) else if (len < 0)
nubus_rewind(ptr, -len, map); nubus_rewind(ptr, -len, map);
} }
@ -148,23 +145,24 @@ static void nubus_move(unsigned char **ptr, int len, int map)
static inline long nubus_expand32(long foo) static inline long nubus_expand32(long foo)
{ {
if(foo & 0x00800000) /* 24bit negative */ if (foo & 0x00800000) /* 24bit negative */
foo |= 0xFF000000; foo |= 0xFF000000;
return foo; return foo;
} }
static inline void *nubus_rom_addr(int slot) static inline void *nubus_rom_addr(int slot)
{ {
/* /*
* Returns the first byte after the card. We then walk * Returns the first byte after the card. We then walk
* backwards to get the lane register and the config * backwards to get the lane register and the config
*/ */
return (void *)(0xF1000000+(slot<<24)); return (void *)(0xF1000000 + (slot << 24));
} }
static unsigned char *nubus_dirptr(const struct nubus_dirent *nd) static unsigned char *nubus_dirptr(const struct nubus_dirent *nd)
{ {
unsigned char *p = nd->base; unsigned char *p = nd->base;
/* Essentially, just step over the bytelanes using whatever /* Essentially, just step over the bytelanes using whatever
offset we might have found */ offset we might have found */
nubus_move(&p, nubus_expand32(nd->data), nd->mask); nubus_move(&p, nubus_expand32(nd->data), nd->mask);
@ -175,36 +173,36 @@ static unsigned char *nubus_dirptr(const struct nubus_dirent *nd)
/* These two are for pulling resource data blocks (i.e. stuff that's /* These two are for pulling resource data blocks (i.e. stuff that's
pointed to with offsets) out of the card ROM. */ pointed to with offsets) out of the card ROM. */
void nubus_get_rsrc_mem(void *dest, const struct nubus_dirent* dirent, void nubus_get_rsrc_mem(void *dest, const struct nubus_dirent *dirent,
int len) int len)
{ {
unsigned char *t = (unsigned char *)dest; unsigned char *t = (unsigned char *)dest;
unsigned char *p = nubus_dirptr(dirent); unsigned char *p = nubus_dirptr(dirent);
while(len)
{ while (len) {
*t++ = nubus_get_rom(&p, 1, dirent->mask); *t++ = nubus_get_rom(&p, 1, dirent->mask);
len--; len--;
} }
} }
EXPORT_SYMBOL(nubus_get_rsrc_mem); EXPORT_SYMBOL(nubus_get_rsrc_mem);
void nubus_get_rsrc_str(void *dest, const struct nubus_dirent* dirent, void nubus_get_rsrc_str(void *dest, const struct nubus_dirent *dirent,
int len) int len)
{ {
unsigned char *t=(unsigned char *)dest; unsigned char *t = (unsigned char *)dest;
unsigned char *p = nubus_dirptr(dirent); unsigned char *p = nubus_dirptr(dirent);
while(len)
{ while (len) {
*t = nubus_get_rom(&p, 1, dirent->mask); *t = nubus_get_rom(&p, 1, dirent->mask);
if(!*t++) if (!*t++)
break; break;
len--; len--;
} }
} }
EXPORT_SYMBOL(nubus_get_rsrc_str); EXPORT_SYMBOL(nubus_get_rsrc_str);
int nubus_get_root_dir(const struct nubus_board* board, int nubus_get_root_dir(const struct nubus_board *board,
struct nubus_dir* dir) struct nubus_dir *dir)
{ {
dir->ptr = dir->base = board->directory; dir->ptr = dir->base = board->directory;
dir->done = 0; dir->done = 0;
@ -214,8 +212,8 @@ int nubus_get_root_dir(const struct nubus_board* board,
EXPORT_SYMBOL(nubus_get_root_dir); EXPORT_SYMBOL(nubus_get_root_dir);
/* This is a slyly renamed version of the above */ /* This is a slyly renamed version of the above */
int nubus_get_func_dir(const struct nubus_dev* dev, int nubus_get_func_dir(const struct nubus_dev *dev,
struct nubus_dir* dir) struct nubus_dir *dir)
{ {
dir->ptr = dir->base = dev->directory; dir->ptr = dir->base = dev->directory;
dir->done = 0; dir->done = 0;
@ -224,11 +222,11 @@ int nubus_get_func_dir(const struct nubus_dev* dev,
} }
EXPORT_SYMBOL(nubus_get_func_dir); EXPORT_SYMBOL(nubus_get_func_dir);
int nubus_get_board_dir(const struct nubus_board* board, int nubus_get_board_dir(const struct nubus_board *board,
struct nubus_dir* dir) struct nubus_dir *dir)
{ {
struct nubus_dirent ent; struct nubus_dirent ent;
dir->ptr = dir->base = board->directory; dir->ptr = dir->base = board->directory;
dir->done = 0; dir->done = 0;
dir->mask = board->lanes; dir->mask = board->lanes;
@ -256,6 +254,7 @@ EXPORT_SYMBOL(nubus_get_subdir);
int nubus_readdir(struct nubus_dir *nd, struct nubus_dirent *ent) int nubus_readdir(struct nubus_dir *nd, struct nubus_dirent *ent)
{ {
u32 resid; u32 resid;
if (nd->done) if (nd->done)
return -1; return -1;
@ -266,25 +265,25 @@ int nubus_readdir(struct nubus_dir *nd, struct nubus_dirent *ent)
resid = nubus_get_rom(&nd->ptr, 4, nd->mask); resid = nubus_get_rom(&nd->ptr, 4, nd->mask);
/* EOL marker, as per the Apple docs */ /* EOL marker, as per the Apple docs */
if((resid&0xff000000) == 0xff000000) if ((resid & 0xff000000) == 0xff000000) {
{
/* Mark it as done */ /* Mark it as done */
nd->done = 1; nd->done = 1;
return -1; return -1;
} }
/* First byte is the resource ID */ /* First byte is the resource ID */
ent->type = resid >> 24; ent->type = resid >> 24;
/* Low 3 bytes might contain data (or might not) */ /* Low 3 bytes might contain data (or might not) */
ent->data = resid & 0xffffff; ent->data = resid & 0xffffff;
ent->mask = nd->mask; ent->mask = nd->mask;
return 0; return 0;
} }
EXPORT_SYMBOL(nubus_readdir); EXPORT_SYMBOL(nubus_readdir);
int nubus_rewinddir(struct nubus_dir* dir) int nubus_rewinddir(struct nubus_dir *dir)
{ {
dir->ptr = dir->base; dir->ptr = dir->base;
dir->done = 0;
return 0; return 0;
} }
EXPORT_SYMBOL(nubus_rewinddir); EXPORT_SYMBOL(nubus_rewinddir);
@ -292,20 +291,15 @@ EXPORT_SYMBOL(nubus_rewinddir);
/* Driver interface functions, more or less like in pci.c */ /* Driver interface functions, more or less like in pci.c */
struct nubus_dev* struct nubus_dev*
nubus_find_device(unsigned short category, nubus_find_device(unsigned short category, unsigned short type,
unsigned short type, unsigned short dr_hw, unsigned short dr_sw,
unsigned short dr_hw, const struct nubus_dev *from)
unsigned short dr_sw,
const struct nubus_dev* from)
{ {
struct nubus_dev* itor = struct nubus_dev *itor = from ? from->next : nubus_devices;
from ? from->next : nubus_devices;
while (itor) { while (itor) {
if (itor->category == category if (itor->category == category && itor->type == type &&
&& itor->type == type itor->dr_hw == dr_hw && itor->dr_sw == dr_sw)
&& itor->dr_hw == dr_hw
&& itor->dr_sw == dr_sw)
return itor; return itor;
itor = itor->next; itor = itor->next;
} }
@ -314,16 +308,13 @@ nubus_find_device(unsigned short category,
EXPORT_SYMBOL(nubus_find_device); EXPORT_SYMBOL(nubus_find_device);
struct nubus_dev* struct nubus_dev*
nubus_find_type(unsigned short category, nubus_find_type(unsigned short category, unsigned short type,
unsigned short type, const struct nubus_dev *from)
const struct nubus_dev* from)
{ {
struct nubus_dev* itor = struct nubus_dev *itor = from ? from->next : nubus_devices;
from ? from->next : nubus_devices;
while (itor) { while (itor) {
if (itor->category == category if (itor->category == category && itor->type == type)
&& itor->type == type)
return itor; return itor;
itor = itor->next; itor = itor->next;
} }
@ -332,12 +323,10 @@ nubus_find_type(unsigned short category,
EXPORT_SYMBOL(nubus_find_type); EXPORT_SYMBOL(nubus_find_type);
struct nubus_dev* struct nubus_dev*
nubus_find_slot(unsigned int slot, nubus_find_slot(unsigned int slot, const struct nubus_dev *from)
const struct nubus_dev* from)
{ {
struct nubus_dev* itor = struct nubus_dev *itor = from ? from->next : nubus_devices;
from ? from->next : nubus_devices;
while (itor) { while (itor) {
if (itor->board->slot == slot) if (itor->board->slot == slot)
return itor; return itor;
@ -348,13 +337,13 @@ nubus_find_slot(unsigned int slot,
EXPORT_SYMBOL(nubus_find_slot); EXPORT_SYMBOL(nubus_find_slot);
int int
nubus_find_rsrc(struct nubus_dir* dir, unsigned char rsrc_type, nubus_find_rsrc(struct nubus_dir *dir, unsigned char rsrc_type,
struct nubus_dirent* ent) struct nubus_dirent *ent)
{ {
while (nubus_readdir(dir, ent) != -1) { while (nubus_readdir(dir, ent) != -1) {
if (ent->type == rsrc_type) if (ent->type == rsrc_type)
return 0; return 0;
} }
return -1; return -1;
} }
EXPORT_SYMBOL(nubus_find_rsrc); EXPORT_SYMBOL(nubus_find_rsrc);
@ -368,77 +357,74 @@ EXPORT_SYMBOL(nubus_find_rsrc);
among other things. The rest of it should go in the /proc code. among other things. The rest of it should go in the /proc code.
For now, we just use it to give verbose boot logs. */ For now, we just use it to give verbose boot logs. */
static int __init nubus_show_display_resource(struct nubus_dev* dev, static int __init nubus_show_display_resource(struct nubus_dev *dev,
const struct nubus_dirent* ent) const struct nubus_dirent *ent)
{ {
switch (ent->type) { switch (ent->type) {
case NUBUS_RESID_GAMMADIR: case NUBUS_RESID_GAMMADIR:
printk(KERN_INFO " gamma directory offset: 0x%06x\n", ent->data); pr_info(" gamma directory offset: 0x%06x\n", ent->data);
break; break;
case 0x0080 ... 0x0085: case 0x0080 ... 0x0085:
printk(KERN_INFO " mode %02X info offset: 0x%06x\n", pr_info(" mode %02X info offset: 0x%06x\n",
ent->type, ent->data); ent->type, ent->data);
break; break;
default: default:
printk(KERN_INFO " unknown resource %02X, data 0x%06x\n", pr_info(" unknown resource %02X, data 0x%06x\n",
ent->type, ent->data); ent->type, ent->data);
} }
return 0; return 0;
} }
static int __init nubus_show_network_resource(struct nubus_dev* dev, static int __init nubus_show_network_resource(struct nubus_dev *dev,
const struct nubus_dirent* ent) const struct nubus_dirent *ent)
{ {
switch (ent->type) { switch (ent->type) {
case NUBUS_RESID_MAC_ADDRESS: case NUBUS_RESID_MAC_ADDRESS:
{ {
char addr[6]; char addr[6];
int i;
nubus_get_rsrc_mem(addr, ent, 6); nubus_get_rsrc_mem(addr, ent, 6);
printk(KERN_INFO " MAC address: "); pr_info(" MAC address: %pM\n", addr);
for (i = 0; i < 6; i++)
printk("%02x%s", addr[i] & 0xff,
i == 5 ? "" : ":");
printk("\n");
break; break;
} }
default: default:
printk(KERN_INFO " unknown resource %02X, data 0x%06x\n", pr_info(" unknown resource %02X, data 0x%06x\n",
ent->type, ent->data); ent->type, ent->data);
} }
return 0; return 0;
} }
static int __init nubus_show_cpu_resource(struct nubus_dev* dev, static int __init nubus_show_cpu_resource(struct nubus_dev *dev,
const struct nubus_dirent* ent) const struct nubus_dirent *ent)
{ {
switch (ent->type) { switch (ent->type) {
case NUBUS_RESID_MEMINFO: case NUBUS_RESID_MEMINFO:
{ {
unsigned long meminfo[2]; unsigned long meminfo[2];
nubus_get_rsrc_mem(&meminfo, ent, 8); nubus_get_rsrc_mem(&meminfo, ent, 8);
printk(KERN_INFO " memory: [ 0x%08lx 0x%08lx ]\n", pr_info(" memory: [ 0x%08lx 0x%08lx ]\n",
meminfo[0], meminfo[1]); meminfo[0], meminfo[1]);
break; break;
} }
case NUBUS_RESID_ROMINFO: case NUBUS_RESID_ROMINFO:
{ {
unsigned long rominfo[2]; unsigned long rominfo[2];
nubus_get_rsrc_mem(&rominfo, ent, 8); nubus_get_rsrc_mem(&rominfo, ent, 8);
printk(KERN_INFO " ROM: [ 0x%08lx 0x%08lx ]\n", pr_info(" ROM: [ 0x%08lx 0x%08lx ]\n",
rominfo[0], rominfo[1]); rominfo[0], rominfo[1]);
break; break;
} }
default: default:
printk(KERN_INFO " unknown resource %02X, data 0x%06x\n", pr_info(" unknown resource %02X, data 0x%06x\n",
ent->type, ent->data); ent->type, ent->data);
} }
return 0; return 0;
} }
static int __init nubus_show_private_resource(struct nubus_dev* dev, static int __init nubus_show_private_resource(struct nubus_dev *dev,
const struct nubus_dirent* ent) const struct nubus_dirent *ent)
{ {
switch (dev->category) { switch (dev->category) {
case NUBUS_CAT_DISPLAY: case NUBUS_CAT_DISPLAY:
@ -451,59 +437,56 @@ static int __init nubus_show_private_resource(struct nubus_dev* dev,
nubus_show_cpu_resource(dev, ent); nubus_show_cpu_resource(dev, ent);
break; break;
default: default:
printk(KERN_INFO " unknown resource %02X, data 0x%06x\n", pr_info(" unknown resource %02X, data 0x%06x\n",
ent->type, ent->data); ent->type, ent->data);
} }
return 0; return 0;
} }
static struct nubus_dev* __init static struct nubus_dev * __init
nubus_get_functional_resource(struct nubus_board* board, nubus_get_functional_resource(struct nubus_board *board, int slot,
int slot, const struct nubus_dirent *parent)
const struct nubus_dirent* parent)
{ {
struct nubus_dir dir; struct nubus_dir dir;
struct nubus_dirent ent; struct nubus_dirent ent;
struct nubus_dev* dev; struct nubus_dev *dev;
printk(KERN_INFO " Function 0x%02x:\n", parent->type); pr_info(" Function 0x%02x:\n", parent->type);
nubus_get_subdir(parent, &dir); nubus_get_subdir(parent, &dir);
/* Apple seems to have botched the ROM on the IIx */ /* Apple seems to have botched the ROM on the IIx */
if (slot == 0 && (unsigned long)dir.base % 2) if (slot == 0 && (unsigned long)dir.base % 2)
dir.base += 1; dir.base += 1;
if (console_loglevel >= CONSOLE_LOGLEVEL_DEBUG) pr_debug("%s: parent is 0x%p, dir is 0x%p\n",
printk(KERN_DEBUG "nubus_get_functional_resource: parent is 0x%p, dir is 0x%p\n", __func__, parent->base, dir.base);
parent->base, dir.base);
/* Actually we should probably panic if this fails */ /* Actually we should probably panic if this fails */
if ((dev = kzalloc(sizeof(*dev), GFP_ATOMIC)) == NULL) if ((dev = kzalloc(sizeof(*dev), GFP_ATOMIC)) == NULL)
return NULL; return NULL;
dev->resid = parent->type; dev->resid = parent->type;
dev->directory = dir.base; dev->directory = dir.base;
dev->board = board; dev->board = board;
while (nubus_readdir(&dir, &ent) != -1) while (nubus_readdir(&dir, &ent) != -1) {
{ switch (ent.type) {
switch(ent.type)
{
case NUBUS_RESID_TYPE: case NUBUS_RESID_TYPE:
{ {
unsigned short nbtdata[4]; unsigned short nbtdata[4];
nubus_get_rsrc_mem(nbtdata, &ent, 8); nubus_get_rsrc_mem(nbtdata, &ent, 8);
dev->category = nbtdata[0]; dev->category = nbtdata[0];
dev->type = nbtdata[1]; dev->type = nbtdata[1];
dev->dr_sw = nbtdata[2]; dev->dr_sw = nbtdata[2];
dev->dr_hw = nbtdata[3]; dev->dr_hw = nbtdata[3];
printk(KERN_INFO " type: [cat 0x%x type 0x%x hw 0x%x sw 0x%x]\n", pr_info(" type: [cat 0x%x type 0x%x sw 0x%x hw 0x%x]\n",
nbtdata[0], nbtdata[1], nbtdata[2], nbtdata[3]); nbtdata[0], nbtdata[1], nbtdata[2], nbtdata[3]);
break; break;
} }
case NUBUS_RESID_NAME: case NUBUS_RESID_NAME:
{ {
nubus_get_rsrc_str(dev->name, &ent, 64); nubus_get_rsrc_str(dev->name, &ent, 64);
printk(KERN_INFO " name: %s\n", dev->name); pr_info(" name: %s\n", dev->name);
break; break;
} }
case NUBUS_RESID_DRVRDIR: case NUBUS_RESID_DRVRDIR:
@ -512,11 +495,11 @@ static struct nubus_dev* __init
use this :-) */ use this :-) */
struct nubus_dir drvr_dir; struct nubus_dir drvr_dir;
struct nubus_dirent drvr_ent; struct nubus_dirent drvr_ent;
nubus_get_subdir(&ent, &drvr_dir); nubus_get_subdir(&ent, &drvr_dir);
nubus_readdir(&drvr_dir, &drvr_ent); nubus_readdir(&drvr_dir, &drvr_ent);
dev->driver = nubus_dirptr(&drvr_ent); dev->driver = nubus_dirptr(&drvr_ent);
printk(KERN_INFO " driver at: 0x%p\n", pr_info(" driver at: 0x%p\n", dev->driver);
dev->driver);
break; break;
} }
case NUBUS_RESID_MINOR_BASEOS: case NUBUS_RESID_MINOR_BASEOS:
@ -524,22 +507,20 @@ static struct nubus_dev* __init
multiple framebuffers. It might be handy multiple framebuffers. It might be handy
for Ethernet as well */ for Ethernet as well */
nubus_get_rsrc_mem(&dev->iobase, &ent, 4); nubus_get_rsrc_mem(&dev->iobase, &ent, 4);
printk(KERN_INFO " memory offset: 0x%08lx\n", pr_info(" memory offset: 0x%08lx\n", dev->iobase);
dev->iobase);
break; break;
case NUBUS_RESID_MINOR_LENGTH: case NUBUS_RESID_MINOR_LENGTH:
/* Ditto */ /* Ditto */
nubus_get_rsrc_mem(&dev->iosize, &ent, 4); nubus_get_rsrc_mem(&dev->iosize, &ent, 4);
printk(KERN_INFO " memory length: 0x%08lx\n", pr_info(" memory length: 0x%08lx\n", dev->iosize);
dev->iosize); break;
break;
case NUBUS_RESID_FLAGS: case NUBUS_RESID_FLAGS:
dev->flags = ent.data; dev->flags = ent.data;
printk(KERN_INFO " flags: 0x%06x\n", dev->flags); pr_info(" flags: 0x%06x\n", dev->flags);
break; break;
case NUBUS_RESID_HWDEVID: case NUBUS_RESID_HWDEVID:
dev->hwdevid = ent.data; dev->hwdevid = ent.data;
printk(KERN_INFO " hwdevid: 0x%06x\n", dev->hwdevid); pr_info(" hwdevid: 0x%06x\n", dev->hwdevid);
break; break;
default: default:
/* Local/Private resources have their own /* Local/Private resources have their own
@ -547,16 +528,17 @@ static struct nubus_dev* __init
nubus_show_private_resource(dev, &ent); nubus_show_private_resource(dev, &ent);
} }
} }
return dev; return dev;
} }
/* This is cool. */ /* This is cool. */
static int __init nubus_get_vidnames(struct nubus_board* board, static int __init nubus_get_vidnames(struct nubus_board *board,
const struct nubus_dirent* parent) const struct nubus_dirent *parent)
{ {
struct nubus_dir dir; struct nubus_dir dir;
struct nubus_dirent ent; struct nubus_dirent ent;
/* FIXME: obviously we want to put this in a header file soon */ /* FIXME: obviously we want to put this in a header file soon */
struct vidmode { struct vidmode {
u32 size; u32 size;
@ -566,100 +548,92 @@ static int __init nubus_get_vidnames(struct nubus_board* board,
char name[32]; char name[32];
}; };
printk(KERN_INFO " video modes supported:\n"); pr_info(" video modes supported:\n");
nubus_get_subdir(parent, &dir); nubus_get_subdir(parent, &dir);
if (console_loglevel >= CONSOLE_LOGLEVEL_DEBUG) pr_debug("%s: parent is 0x%p, dir is 0x%p\n",
printk(KERN_DEBUG "nubus_get_vidnames: parent is 0x%p, dir is 0x%p\n", __func__, parent->base, dir.base);
parent->base, dir.base);
while(nubus_readdir(&dir, &ent) != -1) while (nubus_readdir(&dir, &ent) != -1) {
{
struct vidmode mode; struct vidmode mode;
u32 size; u32 size;
/* First get the length */ /* First get the length */
nubus_get_rsrc_mem(&size, &ent, 4); nubus_get_rsrc_mem(&size, &ent, 4);
/* Now clobber the whole thing */ /* Now clobber the whole thing */
if (size > sizeof(mode) - 1) if (size > sizeof(mode) - 1)
size = sizeof(mode) - 1; size = sizeof(mode) - 1;
memset(&mode, 0, sizeof(mode)); memset(&mode, 0, sizeof(mode));
nubus_get_rsrc_mem(&mode, &ent, size); nubus_get_rsrc_mem(&mode, &ent, size);
printk (KERN_INFO " %02X: (%02X) %s\n", ent.type, pr_info(" %02X: (%02X) %s\n", ent.type,
mode.id, mode.name); mode.id, mode.name);
} }
return 0; return 0;
} }
/* This is *really* cool. */ /* This is *really* cool. */
static int __init nubus_get_icon(struct nubus_board* board, static int __init nubus_get_icon(struct nubus_board *board,
const struct nubus_dirent* ent) const struct nubus_dirent *ent)
{ {
/* Should be 32x32 if my memory serves me correctly */ /* Should be 32x32 if my memory serves me correctly */
unsigned char icon[128]; unsigned char icon[128];
int x, y; int x, y;
nubus_get_rsrc_mem(&icon, ent, 128); nubus_get_rsrc_mem(&icon, ent, 128);
printk(KERN_INFO " icon:\n"); pr_info(" icon:\n");
/* We should actually plot these somewhere in the framebuffer /* We should actually plot these somewhere in the framebuffer
init. This is just to demonstrate that they do, in fact, init. This is just to demonstrate that they do, in fact,
exist */ exist */
for (y = 0; y < 32; y++) { for (y = 0; y < 32; y++) {
printk(KERN_INFO " "); pr_info(" ");
for (x = 0; x < 32; x++) { for (x = 0; x < 32; x++) {
if (icon[y*4 + x/8] if (icon[y * 4 + x / 8] & (0x80 >> (x % 8)))
& (0x80 >> (x%8))) pr_cont("*");
printk("*");
else else
printk(" "); pr_cont(" ");
} }
printk("\n"); pr_cont("\n");
} }
return 0; return 0;
} }
static int __init nubus_get_vendorinfo(struct nubus_board* board, static int __init nubus_get_vendorinfo(struct nubus_board *board,
const struct nubus_dirent* parent) const struct nubus_dirent *parent)
{ {
struct nubus_dir dir; struct nubus_dir dir;
struct nubus_dirent ent; struct nubus_dirent ent;
static char* vendor_fields[6] = {"ID", "serial", "revision", static char *vendor_fields[6] = { "ID", "serial", "revision",
"part", "date", "unknown field"}; "part", "date", "unknown field" };
printk(KERN_INFO " vendor info:\n"); pr_info(" vendor info:\n");
nubus_get_subdir(parent, &dir); nubus_get_subdir(parent, &dir);
if (console_loglevel >= CONSOLE_LOGLEVEL_DEBUG) pr_debug("%s: parent is 0x%p, dir is 0x%p\n",
printk(KERN_DEBUG "nubus_get_vendorinfo: parent is 0x%p, dir is 0x%p\n", __func__, parent->base, dir.base);
parent->base, dir.base);
while(nubus_readdir(&dir, &ent) != -1) while (nubus_readdir(&dir, &ent) != -1) {
{
char name[64]; char name[64];
/* These are all strings, we think */ /* These are all strings, we think */
nubus_get_rsrc_str(name, &ent, 64); nubus_get_rsrc_str(name, &ent, 64);
if (ent.type > 5) if (ent.type > 5)
ent.type = 5; ent.type = 5;
printk(KERN_INFO " %s: %s\n", pr_info(" %s: %s\n", vendor_fields[ent.type - 1], name);
vendor_fields[ent.type-1], name);
} }
return 0; return 0;
} }
static int __init nubus_get_board_resource(struct nubus_board* board, int slot, static int __init nubus_get_board_resource(struct nubus_board *board, int slot,
const struct nubus_dirent* parent) const struct nubus_dirent *parent)
{ {
struct nubus_dir dir; struct nubus_dir dir;
struct nubus_dirent ent; struct nubus_dirent ent;
nubus_get_subdir(parent, &dir);
if (console_loglevel >= CONSOLE_LOGLEVEL_DEBUG)
printk(KERN_DEBUG "nubus_get_board_resource: parent is 0x%p, dir is 0x%p\n",
parent->base, dir.base);
while(nubus_readdir(&dir, &ent) != -1) nubus_get_subdir(parent, &dir);
{ pr_debug("%s: parent is 0x%p, dir is 0x%p\n",
__func__, parent->base, dir.base);
while (nubus_readdir(&dir, &ent) != -1) {
switch (ent.type) { switch (ent.type) {
case NUBUS_RESID_TYPE: case NUBUS_RESID_TYPE:
{ {
@ -668,50 +642,49 @@ static int __init nubus_get_board_resource(struct nubus_board* board, int slot,
useful except insofar as it tells us that useful except insofar as it tells us that
we really are looking at a board resource. */ we really are looking at a board resource. */
nubus_get_rsrc_mem(nbtdata, &ent, 8); nubus_get_rsrc_mem(nbtdata, &ent, 8);
printk(KERN_INFO " type: [cat 0x%x type 0x%x hw 0x%x sw 0x%x]\n", pr_info(" type: [cat 0x%x type 0x%x sw 0x%x hw 0x%x]\n",
nbtdata[0], nbtdata[1], nbtdata[2], nbtdata[0], nbtdata[1], nbtdata[2], nbtdata[3]);
nbtdata[3]);
if (nbtdata[0] != 1 || nbtdata[1] != 0 || if (nbtdata[0] != 1 || nbtdata[1] != 0 ||
nbtdata[2] != 0 || nbtdata[3] != 0) nbtdata[2] != 0 || nbtdata[3] != 0)
printk(KERN_ERR "this sResource is not a board resource!\n"); pr_err("this sResource is not a board resource!\n");
break; break;
} }
case NUBUS_RESID_NAME: case NUBUS_RESID_NAME:
nubus_get_rsrc_str(board->name, &ent, 64); nubus_get_rsrc_str(board->name, &ent, 64);
printk(KERN_INFO " name: %s\n", board->name); pr_info(" name: %s\n", board->name);
break; break;
case NUBUS_RESID_ICON: case NUBUS_RESID_ICON:
nubus_get_icon(board, &ent); nubus_get_icon(board, &ent);
break; break;
case NUBUS_RESID_BOARDID: case NUBUS_RESID_BOARDID:
printk(KERN_INFO " board id: 0x%x\n", ent.data); pr_info(" board id: 0x%x\n", ent.data);
break; break;
case NUBUS_RESID_PRIMARYINIT: case NUBUS_RESID_PRIMARYINIT:
printk(KERN_INFO " primary init offset: 0x%06x\n", ent.data); pr_info(" primary init offset: 0x%06x\n", ent.data);
break; break;
case NUBUS_RESID_VENDORINFO: case NUBUS_RESID_VENDORINFO:
nubus_get_vendorinfo(board, &ent); nubus_get_vendorinfo(board, &ent);
break; break;
case NUBUS_RESID_FLAGS: case NUBUS_RESID_FLAGS:
printk(KERN_INFO " flags: 0x%06x\n", ent.data); pr_info(" flags: 0x%06x\n", ent.data);
break; break;
case NUBUS_RESID_HWDEVID: case NUBUS_RESID_HWDEVID:
printk(KERN_INFO " hwdevid: 0x%06x\n", ent.data); pr_info(" hwdevid: 0x%06x\n", ent.data);
break; break;
case NUBUS_RESID_SECONDINIT: case NUBUS_RESID_SECONDINIT:
printk(KERN_INFO " secondary init offset: 0x%06x\n", ent.data); pr_info(" secondary init offset: 0x%06x\n", ent.data);
break; break;
/* WTF isn't this in the functional resources? */ /* WTF isn't this in the functional resources? */
case NUBUS_RESID_VIDNAMES: case NUBUS_RESID_VIDNAMES:
nubus_get_vidnames(board, &ent); nubus_get_vidnames(board, &ent);
break; break;
/* Same goes for this */ /* Same goes for this */
case NUBUS_RESID_VIDMODES: case NUBUS_RESID_VIDMODES:
printk(KERN_INFO " video mode parameter directory offset: 0x%06x\n", pr_info(" video mode parameter directory offset: 0x%06x\n",
ent.data); ent.data);
break; break;
default: default:
printk(KERN_INFO " unknown resource %02X, data 0x%06x\n", pr_info(" unknown resource %02X, data 0x%06x\n",
ent.type, ent.data); ent.type, ent.data);
} }
} }
@ -722,8 +695,8 @@ static int __init nubus_get_board_resource(struct nubus_board* board, int slot,
sResources in the motherboard ROM */ sResources in the motherboard ROM */
static void __init nubus_find_rom_dir(struct nubus_board* board) static void __init nubus_find_rom_dir(struct nubus_board* board)
{ {
unsigned char* rp; unsigned char *rp;
unsigned char* romdir; unsigned char *romdir;
struct nubus_dir dir; struct nubus_dir dir;
struct nubus_dirent ent; struct nubus_dirent ent;
@ -756,14 +729,14 @@ static void __init nubus_find_rom_dir(struct nubus_board* board)
if (console_loglevel >= CONSOLE_LOGLEVEL_DEBUG) if (console_loglevel >= CONSOLE_LOGLEVEL_DEBUG)
printk(KERN_INFO "nubus_get_rom_dir: entry %02x %06x\n", ent.type, ent.data); printk(KERN_INFO "nubus_get_rom_dir: entry %02x %06x\n", ent.type, ent.data);
/* This one takes us to where we want to go. */ /* This one takes us to where we want to go. */
if (nubus_readdir(&dir, &ent) == -1) if (nubus_readdir(&dir, &ent) == -1)
goto badrom; goto badrom;
if (console_loglevel >= CONSOLE_LOGLEVEL_DEBUG) if (console_loglevel >= CONSOLE_LOGLEVEL_DEBUG)
printk(KERN_DEBUG "nubus_get_rom_dir: entry %02x %06x\n", ent.type, ent.data); printk(KERN_DEBUG "nubus_get_rom_dir: entry %02x %06x\n", ent.type, ent.data);
nubus_get_subdir(&ent, &dir); nubus_get_subdir(&ent, &dir);
/* Resource ID 01, also an "Unknown Macintosh" */ /* Resource ID 01, also an "Unknown Macintosh" */
if (nubus_readdir(&dir, &ent) == -1) if (nubus_readdir(&dir, &ent) == -1)
goto badrom; goto badrom;
if (console_loglevel >= CONSOLE_LOGLEVEL_DEBUG) if (console_loglevel >= CONSOLE_LOGLEVEL_DEBUG)
printk(KERN_DEBUG "nubus_get_rom_dir: entry %02x %06x\n", ent.type, ent.data); printk(KERN_DEBUG "nubus_get_rom_dir: entry %02x %06x\n", ent.type, ent.data);
@ -782,12 +755,12 @@ static void __init nubus_find_rom_dir(struct nubus_board* board)
goto badrom; goto badrom;
if (console_loglevel >= CONSOLE_LOGLEVEL_DEBUG) if (console_loglevel >= CONSOLE_LOGLEVEL_DEBUG)
printk(KERN_DEBUG "nubus_get_rom_dir: entry %02x %06x\n", ent.type, ent.data); printk(KERN_DEBUG "nubus_get_rom_dir: entry %02x %06x\n", ent.type, ent.data);
/* Bwahahahaha... */ /* Bwahahahaha... */
nubus_get_subdir(&ent, &dir); nubus_get_subdir(&ent, &dir);
board->directory = dir.base; board->directory = dir.base;
return; return;
/* Even more evil laughter... */ /* Even more evil laughter... */
badrom: badrom:
board->directory = board->fblock; board->directory = board->fblock;
@ -796,43 +769,38 @@ static void __init nubus_find_rom_dir(struct nubus_board* board)
} }
/* Add a board (might be many devices) to the list */ /* Add a board (might be many devices) to the list */
static struct nubus_board* __init nubus_add_board(int slot, int bytelanes) static struct nubus_board * __init nubus_add_board(int slot, int bytelanes)
{ {
struct nubus_board* board; struct nubus_board *board;
struct nubus_board** boardp; struct nubus_board **boardp;
unsigned char *rp; unsigned char *rp;
unsigned long dpat; unsigned long dpat;
struct nubus_dir dir; struct nubus_dir dir;
struct nubus_dirent ent; struct nubus_dirent ent;
/* Move to the start of the format block */ /* Move to the start of the format block */
rp = nubus_rom_addr(slot); rp = nubus_rom_addr(slot);
nubus_rewind(&rp, FORMAT_BLOCK_SIZE, bytelanes); nubus_rewind(&rp, FORMAT_BLOCK_SIZE, bytelanes);
/* Actually we should probably panic if this fails */ /* Actually we should probably panic if this fails */
if ((board = kzalloc(sizeof(*board), GFP_ATOMIC)) == NULL) if ((board = kzalloc(sizeof(*board), GFP_ATOMIC)) == NULL)
return NULL; return NULL;
board->fblock = rp; board->fblock = rp;
/* Dump the format block for debugging purposes */ /* Dump the format block for debugging purposes */
if (console_loglevel >= CONSOLE_LOGLEVEL_DEBUG) { pr_debug("Slot %X, format block at 0x%p:\n", slot, rp);
int i; pr_debug("%02lx\n", nubus_get_rom(&rp, 1, bytelanes));
printk(KERN_DEBUG "Slot %X, format block at 0x%p\n", pr_debug("%02lx\n", nubus_get_rom(&rp, 1, bytelanes));
slot, rp); pr_debug("%08lx\n", nubus_get_rom(&rp, 4, bytelanes));
printk(KERN_DEBUG "Format block: "); pr_debug("%02lx\n", nubus_get_rom(&rp, 1, bytelanes));
for (i = 0; i < FORMAT_BLOCK_SIZE; i += 4) { pr_debug("%02lx\n", nubus_get_rom(&rp, 1, bytelanes));
unsigned short foo, bar; pr_debug("%08lx\n", nubus_get_rom(&rp, 4, bytelanes));
foo = nubus_get_rom(&rp, 2, bytelanes); pr_debug("%08lx\n", nubus_get_rom(&rp, 4, bytelanes));
bar = nubus_get_rom(&rp, 2, bytelanes); pr_debug("%08lx\n", nubus_get_rom(&rp, 4, bytelanes));
printk("%04x %04x ", foo, bar); rp = board->fblock;
}
printk("\n");
rp = board->fblock;
}
board->slot = slot; board->slot = slot;
board->slot_addr = (unsigned long) nubus_slot_addr(slot); board->slot_addr = (unsigned long)nubus_slot_addr(slot);
board->doffset = nubus_get_rom(&rp, 4, bytelanes); board->doffset = nubus_get_rom(&rp, 4, bytelanes);
/* rom_length is *supposed* to be the total length of the /* rom_length is *supposed* to be the total length of the
* ROM. In practice it is the "amount of ROM used to compute * ROM. In practice it is the "amount of ROM used to compute
@ -843,16 +811,16 @@ static struct nubus_board* __init nubus_add_board(int slot, int bytelanes)
board->rom_length = nubus_get_rom(&rp, 4, bytelanes); board->rom_length = nubus_get_rom(&rp, 4, bytelanes);
board->crc = nubus_get_rom(&rp, 4, bytelanes); board->crc = nubus_get_rom(&rp, 4, bytelanes);
board->rev = nubus_get_rom(&rp, 1, bytelanes); board->rev = nubus_get_rom(&rp, 1, bytelanes);
board->format = nubus_get_rom(&rp,1, bytelanes); board->format = nubus_get_rom(&rp, 1, bytelanes);
board->lanes = bytelanes; board->lanes = bytelanes;
/* Directory offset should be small and negative... */ /* Directory offset should be small and negative... */
if(!(board->doffset & 0x00FF0000)) if (!(board->doffset & 0x00FF0000))
printk(KERN_WARNING "Dodgy doffset!\n"); pr_warn("Dodgy doffset!\n");
dpat = nubus_get_rom(&rp, 4, bytelanes); dpat = nubus_get_rom(&rp, 4, bytelanes);
if(dpat != NUBUS_TEST_PATTERN) if (dpat != NUBUS_TEST_PATTERN)
printk(KERN_WARNING "Wrong test pattern %08lx!\n", dpat); pr_warn("Wrong test pattern %08lx!\n", dpat);
/* /*
* I wonder how the CRC is meant to work - * I wonder how the CRC is meant to work -
* any takers ? * any takers ?
@ -862,10 +830,10 @@ static struct nubus_board* __init nubus_add_board(int slot, int bytelanes)
/* Attempt to work around slot zero weirdness */ /* Attempt to work around slot zero weirdness */
nubus_find_rom_dir(board); nubus_find_rom_dir(board);
nubus_get_root_dir(board, &dir); nubus_get_root_dir(board, &dir);
/* We're ready to rock */ /* We're ready to rock */
printk(KERN_INFO "Slot %X:\n", slot); pr_info("Slot %X:\n", slot);
/* Each slot should have one board resource and any number of /* Each slot should have one board resource and any number of
functional resources. So we'll fill in some fields in the functional resources. So we'll fill in some fields in the
@ -874,10 +842,10 @@ static struct nubus_board* __init nubus_add_board(int slot, int bytelanes)
for each of them. */ for each of them. */
if (nubus_readdir(&dir, &ent) == -1) { if (nubus_readdir(&dir, &ent) == -1) {
/* We can't have this! */ /* We can't have this! */
printk(KERN_ERR "Board resource not found!\n"); pr_err("Board resource not found!\n");
return NULL; return NULL;
} else { } else {
printk(KERN_INFO " Board resource:\n"); pr_info(" Board resource:\n");
nubus_get_board_resource(board, slot, &ent); nubus_get_board_resource(board, slot, &ent);
} }
@ -885,8 +853,9 @@ static struct nubus_board* __init nubus_add_board(int slot, int bytelanes)
resources. I have no idea WTF to do about this. */ resources. I have no idea WTF to do about this. */
while (nubus_readdir(&dir, &ent) != -1) { while (nubus_readdir(&dir, &ent) != -1) {
struct nubus_dev* dev; struct nubus_dev *dev;
struct nubus_dev** devp; struct nubus_dev **devp;
dev = nubus_get_functional_resource(board, slot, &ent); dev = nubus_get_functional_resource(board, slot, &ent);
if (dev == NULL) if (dev == NULL)
continue; continue;
@ -894,32 +863,33 @@ static struct nubus_board* __init nubus_add_board(int slot, int bytelanes)
/* We zeroed this out above */ /* We zeroed this out above */
if (board->first_dev == NULL) if (board->first_dev == NULL)
board->first_dev = dev; board->first_dev = dev;
/* Put it on the global NuBus device chain. Keep entries in order. */ /* Put it on the global NuBus device chain. Keep entries in order. */
for (devp=&nubus_devices; *devp!=NULL; devp=&((*devp)->next)) for (devp = &nubus_devices; *devp != NULL;
devp = &((*devp)->next))
/* spin */; /* spin */;
*devp = dev; *devp = dev;
dev->next = NULL; dev->next = NULL;
} }
/* Put it on the global NuBus board chain. Keep entries in order. */ /* Put it on the global NuBus board chain. Keep entries in order. */
for (boardp=&nubus_boards; *boardp!=NULL; boardp=&((*boardp)->next)) for (boardp = &nubus_boards; *boardp != NULL;
boardp = &((*boardp)->next))
/* spin */; /* spin */;
*boardp = board; *boardp = board;
board->next = NULL; board->next = NULL;
return board; return board;
} }
void __init nubus_probe_slot(int slot) void __init nubus_probe_slot(int slot)
{ {
unsigned char dp; unsigned char dp;
unsigned char* rp; unsigned char *rp;
int i; int i;
rp = nubus_rom_addr(slot); rp = nubus_rom_addr(slot);
for(i = 4; i; i--) for (i = 4; i; i--) {
{
int card_present; int card_present;
rp--; rp--;
@ -927,7 +897,6 @@ void __init nubus_probe_slot(int slot)
if (!card_present) if (!card_present)
continue; continue;
printk(KERN_DEBUG "Now probing slot %X at %p\n", slot, rp);
dp = *rp; dp = *rp;
if(dp == 0) if(dp == 0)
continue; continue;
@ -935,11 +904,11 @@ void __init nubus_probe_slot(int slot)
/* The last byte of the format block consists of two /* The last byte of the format block consists of two
nybbles which are "mirror images" of each other. nybbles which are "mirror images" of each other.
These show us the valid bytelanes */ These show us the valid bytelanes */
if ((((dp>>4) ^ dp) & 0x0F) != 0x0F) if ((((dp >> 4) ^ dp) & 0x0F) != 0x0F)
continue; continue;
/* Check that this value is actually *on* one of the /* Check that this value is actually *on* one of the
bytelanes it claims are valid! */ bytelanes it claims are valid! */
if ((dp & 0x0F) >= (1<<i)) if ((dp & 0x0F) >= (1 << i))
continue; continue;
/* Looks promising. Let's put it on the list. */ /* Looks promising. Let's put it on the list. */
@ -952,19 +921,19 @@ void __init nubus_probe_slot(int slot)
void __init nubus_scan_bus(void) void __init nubus_scan_bus(void)
{ {
int slot; int slot;
/* This might not work on your machine */ /* This might not work on your machine */
#ifdef I_WANT_TO_PROBE_SLOT_ZERO #ifdef I_WANT_TO_PROBE_SLOT_ZERO
nubus_probe_slot(0); nubus_probe_slot(0);
#endif #endif
for(slot = 9; slot < 15; slot++) for (slot = 9; slot < 15; slot++) {
{
nubus_probe_slot(slot); nubus_probe_slot(slot);
} }
} }
static int __init nubus_init(void) static int __init nubus_init(void)
{ {
if (!MACH_IS_MAC) if (!MACH_IS_MAC)
return 0; return 0;
/* Initialize the NuBus interrupts */ /* Initialize the NuBus interrupts */
@ -980,11 +949,11 @@ static int __init nubus_init(void)
gurus can fix the real cause of the problem. */ gurus can fix the real cause of the problem. */
mdelay(1000); mdelay(1000);
#endif #endif
/* And probe */ /* And probe */
printk("NuBus: Scanning NuBus slots.\n"); pr_info("NuBus: Scanning NuBus slots.\n");
nubus_devices = NULL; nubus_devices = NULL;
nubus_boards = NULL; nubus_boards = NULL;
nubus_scan_bus(); nubus_scan_bus();
nubus_proc_init(); nubus_proc_init();
return 0; return 0;

4
include/uapi/linux/nubus.h
View file

@ -113,13 +113,15 @@ enum nubus_drhw {
NUBUS_DRHW_SIGMA_CLRMAX = 0x0007, /* Sigma Design ColorMax */ NUBUS_DRHW_SIGMA_CLRMAX = 0x0007, /* Sigma Design ColorMax */
NUBUS_DRHW_APPLE_SE30 = 0x0009, /* Apple SE/30 video */ NUBUS_DRHW_APPLE_SE30 = 0x0009, /* Apple SE/30 video */
NUBUS_DRHW_APPLE_HRVC = 0x0013, /* Mac II High-Res Video Card */ NUBUS_DRHW_APPLE_HRVC = 0x0013, /* Mac II High-Res Video Card */
NUBUS_DRHW_APPLE_MVC = 0x0014, /* Mac II Monochrome Video Card */
NUBUS_DRHW_APPLE_PVC = 0x0017, /* Mac II Portrait Video Card */ NUBUS_DRHW_APPLE_PVC = 0x0017, /* Mac II Portrait Video Card */
NUBUS_DRHW_APPLE_RBV1 = 0x0018, /* IIci RBV video */ NUBUS_DRHW_APPLE_RBV1 = 0x0018, /* IIci RBV video */
NUBUS_DRHW_APPLE_MDC = 0x0019, /* Macintosh Display Card */ NUBUS_DRHW_APPLE_MDC = 0x0019, /* Macintosh Display Card */
NUBUS_DRHW_APPLE_VSC = 0x0020, /* Duo MiniDock ViSC framebuffer */
NUBUS_DRHW_APPLE_SONORA = 0x0022, /* Sonora built-in video */ NUBUS_DRHW_APPLE_SONORA = 0x0022, /* Sonora built-in video */
NUBUS_DRHW_APPLE_JET = 0x0029, /* Jet framebuffer (DuoDock) */
NUBUS_DRHW_APPLE_24AC = 0x002b, /* Mac 24AC Video Card */ NUBUS_DRHW_APPLE_24AC = 0x002b, /* Mac 24AC Video Card */
NUBUS_DRHW_APPLE_VALKYRIE = 0x002e, NUBUS_DRHW_APPLE_VALKYRIE = 0x002e,
NUBUS_DRHW_APPLE_JET = 0x0029, /* Jet framebuffer (DuoDock) */
NUBUS_DRHW_SMAC_GFX = 0x0105, /* SuperMac GFX */ NUBUS_DRHW_SMAC_GFX = 0x0105, /* SuperMac GFX */
NUBUS_DRHW_RASTER_CB264 = 0x013B, /* RasterOps ColorBoard 264 */ NUBUS_DRHW_RASTER_CB264 = 0x013B, /* RasterOps ColorBoard 264 */
NUBUS_DRHW_MICRON_XCEED = 0x0146, /* Micron Exceed color */ NUBUS_DRHW_MICRON_XCEED = 0x0146, /* Micron Exceed color */