/* -*- linux-c -*- * arch/ppc64/viopath.c * * iSeries Virtual I/O Message Path code * * Authors: Dave Boutcher * Ryan Arnold * Colin Devilbiss * * (C) Copyright 2000 IBM Corporation * * This code is used by the iSeries virtual disk, cd, * tape, and console to communicate with OS/400 in another * partition. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) anyu later version. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include EXPORT_SYMBOL(viopath_hostLp); EXPORT_SYMBOL(viopath_ourLp); EXPORT_SYMBOL(vio_set_hostlp); EXPORT_SYMBOL(vio_lookup_rc); EXPORT_SYMBOL(viopath_open); EXPORT_SYMBOL(viopath_close); EXPORT_SYMBOL(viopath_isactive); EXPORT_SYMBOL(viopath_sourceinst); EXPORT_SYMBOL(viopath_targetinst); EXPORT_SYMBOL(vio_setHandler); EXPORT_SYMBOL(vio_clearHandler); EXPORT_SYMBOL(vio_get_event_buffer); EXPORT_SYMBOL(vio_free_event_buffer); extern struct pci_dev *iSeries_vio_dev; /* Status of the path to each other partition in the system. * This is overkill, since we will only ever establish connections * to our hosting partition and the primary partition on the system. * But this allows for other support in the future. */ static struct viopathStatus { int isOpen:1; /* Did we open the path? */ int isActive:1; /* Do we have a mon msg outstanding */ int users[VIO_MAX_SUBTYPES]; HvLpInstanceId mSourceInst; HvLpInstanceId mTargetInst; int numberAllocated; } viopathStatus[HVMAXARCHITECTEDLPS]; static spinlock_t statuslock = SPIN_LOCK_UNLOCKED; /* * For each kind of event we allocate a buffer that is * guaranteed not to cross a page boundary */ static void *event_buffer[VIO_MAX_SUBTYPES] = { }; static atomic_t event_buffer_available[VIO_MAX_SUBTYPES] = { }; static void handleMonitorEvent(struct HvLpEvent *event); /* We use this structure to handle asynchronous responses. The caller * blocks on the semaphore and the handler posts the semaphore. */ struct doneAllocParms_t { struct semaphore *sem; int number; }; /* Put a sequence number in each mon msg. The value is not * important. Start at something other than 0 just for * readability. wrapping this is ok. */ static u8 viomonseq = 22; /* Our hosting logical partition. We get this at startup * time, and different modules access this variable directly. */ HvLpIndex viopath_hostLp = 0xff; /* HvLpIndexInvalid */ HvLpIndex viopath_ourLp = 0xff; /* For each kind of incoming event we set a pointer to a * routine to call. */ static vio_event_handler_t *vio_handler[VIO_MAX_SUBTYPES]; static unsigned char e2a(unsigned char x) { switch (x) { case 0xF0: return '0'; case 0xF1: return '1'; case 0xF2: return '2'; case 0xF3: return '3'; case 0xF4: return '4'; case 0xF5: return '5'; case 0xF6: return '6'; case 0xF7: return '7'; case 0xF8: return '8'; case 0xF9: return '9'; case 0xC1: return 'A'; case 0xC2: return 'B'; case 0xC3: return 'C'; case 0xC4: return 'D'; case 0xC5: return 'E'; case 0xC6: return 'F'; case 0xC7: return 'G'; case 0xC8: return 'H'; case 0xC9: return 'I'; case 0xD1: return 'J'; case 0xD2: return 'K'; case 0xD3: return 'L'; case 0xD4: return 'M'; case 0xD5: return 'N'; case 0xD6: return 'O'; case 0xD7: return 'P'; case 0xD8: return 'Q'; case 0xD9: return 'R'; case 0xE2: return 'S'; case 0xE3: return 'T'; case 0xE4: return 'U'; case 0xE5: return 'V'; case 0xE6: return 'W'; case 0xE7: return 'X'; case 0xE8: return 'Y'; case 0xE9: return 'Z'; } return ' '; } /* Handle reads from the proc file system */ static int proc_read(char *buf, char **start, off_t offset, int blen, int *eof, void *data) { HvLpEvent_Rc hvrc; DECLARE_MUTEX_LOCKED(Semaphore); dma_addr_t dmaa = pci_map_single(iSeries_vio_dev, buf, PAGE_SIZE, PCI_DMA_FROMDEVICE); int len = PAGE_SIZE; if (len > blen) len = blen; memset(buf, 0x00, len); hvrc = HvCallEvent_signalLpEventFast(viopath_hostLp, HvLpEvent_Type_VirtualIo, viomajorsubtype_config | vioconfigget, HvLpEvent_AckInd_DoAck, HvLpEvent_AckType_ImmediateAck, viopath_sourceinst (viopath_hostLp), viopath_targetinst (viopath_hostLp), (u64) (unsigned long) &Semaphore, VIOVERSION << 16, ((u64) dmaa) << 32, len, 0, 0); if (hvrc != HvLpEvent_Rc_Good) { printk("viopath hv error on op %d\n", (int) hvrc); } down(&Semaphore); pci_unmap_single(iSeries_vio_dev, dmaa, PAGE_SIZE, PCI_DMA_FROMDEVICE); sprintf(buf + strlen(buf), "SRLNBR="); buf[strlen(buf)] = e2a(xItExtVpdPanel.mfgID[2]); buf[strlen(buf)] = e2a(xItExtVpdPanel.mfgID[3]); buf[strlen(buf)] = e2a(xItExtVpdPanel.systemSerial[1]); buf[strlen(buf)] = e2a(xItExtVpdPanel.systemSerial[2]); buf[strlen(buf)] = e2a(xItExtVpdPanel.systemSerial[3]); buf[strlen(buf)] = e2a(xItExtVpdPanel.systemSerial[4]); buf[strlen(buf)] = e2a(xItExtVpdPanel.systemSerial[5]); buf[strlen(buf)] = '\n'; *eof = 1; return strlen(buf); } /* Handle writes to our proc file system */ static int proc_write(struct file *file, const char *buffer, unsigned long count, void *data) { /* Doesn't do anything today!!! */ return count; } /* setup our proc file system entries */ static void vio_proc_init(struct proc_dir_entry *iSeries_proc) { struct proc_dir_entry *ent; ent = create_proc_entry("config", S_IFREG | S_IRUSR, iSeries_proc); if (!ent) return; ent->nlink = 1; ent->data = NULL; ent->read_proc = proc_read; ent->write_proc = proc_write; } /* See if a given LP is active. Allow for invalid lps to be passed in * and just return invalid */ int viopath_isactive(HvLpIndex lp) { if (lp == HvLpIndexInvalid) return 0; if (lp < HVMAXARCHITECTEDLPS) return viopathStatus[lp].isActive; else return 0; } /* We cache the source and target instance ids for each * partition. */ HvLpInstanceId viopath_sourceinst(HvLpIndex lp) { return viopathStatus[lp].mSourceInst; } HvLpInstanceId viopath_targetinst(HvLpIndex lp) { return viopathStatus[lp].mTargetInst; } /* Send a monitor message. This is a message with the acknowledge * bit on that the other side will NOT explicitly acknowledge. When * the other side goes down, the hypervisor will acknowledge any * outstanding messages....so we will know when the other side dies. */ static void sendMonMsg(HvLpIndex remoteLp) { HvLpEvent_Rc hvrc; viopathStatus[remoteLp].mSourceInst = HvCallEvent_getSourceLpInstanceId(remoteLp, HvLpEvent_Type_VirtualIo); viopathStatus[remoteLp].mTargetInst = HvCallEvent_getTargetLpInstanceId(remoteLp, HvLpEvent_Type_VirtualIo); /* Deliberately ignore the return code here. if we call this * more than once, we don't care. */ vio_setHandler(viomajorsubtype_monitor, handleMonitorEvent); hvrc = HvCallEvent_signalLpEventFast(remoteLp, HvLpEvent_Type_VirtualIo, viomajorsubtype_monitor, HvLpEvent_AckInd_DoAck, HvLpEvent_AckType_DeferredAck, viopathStatus[remoteLp]. mSourceInst, viopathStatus[remoteLp]. mTargetInst, viomonseq++, 0, 0, 0, 0, 0); if (hvrc == HvLpEvent_Rc_Good) { viopathStatus[remoteLp].isActive = 1; } else { printk(KERN_WARNING_VIO "could not connect to partition %d\n", remoteLp); viopathStatus[remoteLp].isActive = 0; } } static void handleMonitorEvent(struct HvLpEvent *event) { HvLpIndex remoteLp; int i; /* This handler is _also_ called as part of the loop * at the end of this routine, so it must be able to * ignore NULL events... */ if (!event) return; /* First see if this is just a normal monitor message from the * other partition */ if (event->xFlags.xFunction == HvLpEvent_Function_Int) { remoteLp = event->xSourceLp; if (!viopathStatus[remoteLp].isActive) sendMonMsg(remoteLp); return; } /* This path is for an acknowledgement; the other partition * died */ remoteLp = event->xTargetLp; if ((event->xSourceInstanceId != viopathStatus[remoteLp].mSourceInst) || (event->xTargetInstanceId != viopathStatus[remoteLp].mTargetInst)) { printk(KERN_WARNING_VIO "ignoring ack....mismatched instances\n"); return; } printk(KERN_WARNING_VIO "partition %d ended\n", remoteLp); viopathStatus[remoteLp].isActive = 0; /* For each active handler, pass them a NULL * message to indicate that the other partition * died */ for (i = 0; i < VIO_MAX_SUBTYPES; i++) { if (vio_handler[i] != NULL) (*vio_handler[i]) (NULL); } } int vio_setHandler(int subtype, vio_event_handler_t * beh) { subtype = subtype >> VIOMAJOR_SUBTYPE_SHIFT; if ((subtype < 0) || (subtype >= VIO_MAX_SUBTYPES)) return -EINVAL; if (vio_handler[subtype] != NULL) return -EBUSY; vio_handler[subtype] = beh; return 0; } int vio_clearHandler(int subtype) { subtype = subtype >> VIOMAJOR_SUBTYPE_SHIFT; if ((subtype < 0) || (subtype >= VIO_MAX_SUBTYPES)) return -EINVAL; if (vio_handler[subtype] == NULL) return -EAGAIN; vio_handler[subtype] = NULL; return 0; } static void handleConfig(struct HvLpEvent *event) { if (!event) return; if (event->xFlags.xFunction == HvLpEvent_Function_Int) { printk(KERN_WARNING_VIO "unexpected config request from partition %d", event->xSourceLp); if ((event->xFlags.xFunction == HvLpEvent_Function_Int) && (event->xFlags.xAckInd == HvLpEvent_AckInd_DoAck)) { event->xRc = HvLpEvent_Rc_InvalidSubtype; HvCallEvent_ackLpEvent(event); } return; } up((struct semaphore *) event->xCorrelationToken); } /* Initialization of the hosting partition */ void vio_set_hostlp(void) { /* If this has already been set then we DON'T want to either change * it or re-register the proc file system */ if (viopath_hostLp != HvLpIndexInvalid) return; /* Figure out our hosting partition. This isn't allowed to change * while we're active */ viopath_ourLp = HvLpConfig_getLpIndex(); viopath_hostLp = HvCallCfg_getHostingLpIndex(viopath_ourLp); /* If we have a valid hosting LP, create a proc file system entry * for config information */ if (viopath_hostLp != HvLpIndexInvalid) { iSeries_proc_callback(&vio_proc_init); vio_setHandler(viomajorsubtype_config, handleConfig); } } static void vio_handleEvent(struct HvLpEvent *event, struct pt_regs *regs) { HvLpIndex remoteLp; int subtype = (event-> xSubtype & VIOMAJOR_SUBTYPE_MASK) >> VIOMAJOR_SUBTYPE_SHIFT; if (event->xFlags.xFunction == HvLpEvent_Function_Int) { remoteLp = event->xSourceLp; /* The isActive is checked because if the hosting partition * went down and came back up it would not be active but it would have * different source and target instances, in which case we'd want to * reset them. This case really protects against an unauthorized * active partition sending interrupts or acks to this linux partition. */ if (viopathStatus[remoteLp].isActive && (event->xSourceInstanceId != viopathStatus[remoteLp].mTargetInst)) { printk(KERN_WARNING_VIO "message from invalid partition. " "int msg rcvd, source inst (%d) doesnt match (%d)\n", viopathStatus[remoteLp].mTargetInst, event->xSourceInstanceId); return; } if (viopathStatus[remoteLp].isActive && (event->xTargetInstanceId != viopathStatus[remoteLp].mSourceInst)) { printk(KERN_WARNING_VIO "message from invalid partition. " "int msg rcvd, target inst (%d) doesnt match (%d)\n", viopathStatus[remoteLp].mSourceInst, event->xTargetInstanceId); return; } } else { remoteLp = event->xTargetLp; if (event->xSourceInstanceId != viopathStatus[remoteLp].mSourceInst) { printk(KERN_WARNING_VIO "message from invalid partition. " "ack msg rcvd, source inst (%d) doesnt match (%d)\n", viopathStatus[remoteLp].mSourceInst, event->xSourceInstanceId); return; } if (event->xTargetInstanceId != viopathStatus[remoteLp].mTargetInst) { printk(KERN_WARNING_VIO "message from invalid partition. " "viopath: ack msg rcvd, target inst (%d) doesnt match (%d)\n", viopathStatus[remoteLp].mTargetInst, event->xTargetInstanceId); return; } } if (vio_handler[subtype] == NULL) { printk(KERN_WARNING_VIO "unexpected virtual io event subtype %d from partition %d\n", event->xSubtype, remoteLp); /* No handler. Ack if necessary */ if ((event->xFlags.xFunction == HvLpEvent_Function_Int) && (event->xFlags.xAckInd == HvLpEvent_AckInd_DoAck)) { event->xRc = HvLpEvent_Rc_InvalidSubtype; HvCallEvent_ackLpEvent(event); } return; } /* This innocuous little line is where all the real work happens */ (*vio_handler[subtype]) (event); } static void viopath_donealloc(void *parm, int number) { struct doneAllocParms_t *doneAllocParmsp = (struct doneAllocParms_t *) parm; doneAllocParmsp->number = number; up(doneAllocParmsp->sem); } static int allocateEvents(HvLpIndex remoteLp, int numEvents) { struct doneAllocParms_t doneAllocParms; DECLARE_MUTEX_LOCKED(Semaphore); doneAllocParms.sem = &Semaphore; mf_allocateLpEvents(remoteLp, HvLpEvent_Type_VirtualIo, 250, /* It would be nice to put a real number here! */ numEvents, &viopath_donealloc, &doneAllocParms); down(&Semaphore); return doneAllocParms.number; } int viopath_open(HvLpIndex remoteLp, int subtype, int numReq) { int i; unsigned long flags; void *tempEventBuffer = NULL; int tempNumAllocated; if ((remoteLp >= HvMaxArchitectedLps) || (remoteLp == HvLpIndexInvalid)) return -EINVAL; subtype = subtype >> VIOMAJOR_SUBTYPE_SHIFT; if ((subtype < 0) || (subtype >= VIO_MAX_SUBTYPES)) return -EINVAL; /* * NOTE: If VIO_MAX_SUBTYPES exceeds 16 then we need * to allocate more than one page for the event_buffer. */ if (event_buffer[0] == NULL) { if (VIO_MAX_SUBTYPES <= 16) { tempEventBuffer = (void *) get_free_page(GFP_KERNEL); if (tempEventBuffer == NULL) return -ENOMEM; } else { printk(KERN_INFO_VIO "VIO_MAX_SUBTYPES > 16. Need more space."); return -ENOMEM; } } spin_lock_irqsave(&statuslock, flags); /* * OK...we can fit 16 maximum-sized events (256 bytes) in * each page (4096). */ if (event_buffer[0] == NULL) { event_buffer[0] = tempEventBuffer; atomic_set(&event_buffer_available[0], 1); /* * Start at the second element because we've already * set the pointer for the first element and set the * pointers for every 256 bytes in the page we * allocated earlier. */ for (i = 1; i < VIO_MAX_SUBTYPES; i++) { event_buffer[i] = event_buffer[i - 1] + 256; atomic_set(&event_buffer_available[i], 1); } } else { /* * While we were fetching the pages, which shouldn't * be done in a spin lock, another call to viopath_open * decided to do the same thing and allocated storage * and set the event_buffer before we could so we'll * free the one that we allocated and continue with our * viopath_open operation. */ free_page((unsigned long) tempEventBuffer); } viopathStatus[remoteLp].users[subtype]++; if (!viopathStatus[remoteLp].isOpen) { viopathStatus[remoteLp].isOpen = 1; HvCallEvent_openLpEventPath(remoteLp, HvLpEvent_Type_VirtualIo); spin_unlock_irqrestore(&statuslock, flags); /* * Don't hold the spinlock during an operation that * can sleep. */ tempNumAllocated = allocateEvents(remoteLp, 1); spin_lock_irqsave(&statuslock, flags); viopathStatus[remoteLp].numberAllocated += tempNumAllocated; if (viopathStatus[remoteLp].numberAllocated == 0) { HvCallEvent_closeLpEventPath(remoteLp, HvLpEvent_Type_VirtualIo); spin_unlock_irqrestore(&statuslock, flags); return -ENOMEM; } viopathStatus[remoteLp].mSourceInst = HvCallEvent_getSourceLpInstanceId(remoteLp, HvLpEvent_Type_VirtualIo); viopathStatus[remoteLp].mTargetInst = HvCallEvent_getTargetLpInstanceId(remoteLp, HvLpEvent_Type_VirtualIo); HvLpEvent_registerHandler(HvLpEvent_Type_VirtualIo, &vio_handleEvent); sendMonMsg(remoteLp); printk(KERN_INFO_VIO "Opening connection to partition %d, setting sinst %d, tinst %d\n", remoteLp, viopathStatus[remoteLp].mSourceInst, viopathStatus[remoteLp].mTargetInst); } spin_unlock_irqrestore(&statuslock, flags); tempNumAllocated = allocateEvents(remoteLp, numReq); spin_lock_irqsave(&statuslock, flags); viopathStatus[remoteLp].numberAllocated += tempNumAllocated; spin_unlock_irqrestore(&statuslock, flags); return 0; } int viopath_close(HvLpIndex remoteLp, int subtype, int numReq) { unsigned long flags; int i; int numOpen; struct doneAllocParms_t doneAllocParms; DECLARE_MUTEX_LOCKED(Semaphore); doneAllocParms.sem = &Semaphore; if ((remoteLp >= HvMaxArchitectedLps) || (remoteLp == HvLpIndexInvalid)) return -EINVAL; subtype = subtype >> VIOMAJOR_SUBTYPE_SHIFT; if ((subtype < 0) || (subtype >= VIO_MAX_SUBTYPES)) return -EINVAL; spin_lock_irqsave(&statuslock, flags); /* * If the viopath_close somehow gets called before a * viopath_open it could decrement to -1 which is a non * recoverable state so we'll prevent this from * happening. */ if (viopathStatus[remoteLp].users[subtype] > 0) { viopathStatus[remoteLp].users[subtype]--; } spin_unlock_irqrestore(&statuslock, flags); mf_deallocateLpEvents(remoteLp, HvLpEvent_Type_VirtualIo, numReq, &viopath_donealloc, &doneAllocParms); down(&Semaphore); spin_lock_irqsave(&statuslock, flags); for (i = 0, numOpen = 0; i < VIO_MAX_SUBTYPES; i++) { numOpen += viopathStatus[remoteLp].users[i]; } if ((viopathStatus[remoteLp].isOpen) && (numOpen == 0)) { printk(KERN_INFO_VIO "Closing connection to partition %d", remoteLp); HvCallEvent_closeLpEventPath(remoteLp, HvLpEvent_Type_VirtualIo); viopathStatus[remoteLp].isOpen = 0; viopathStatus[remoteLp].isActive = 0; for (i = 0; i < VIO_MAX_SUBTYPES; i++) { atomic_set(&event_buffer_available[i], 0); } /* * Precautionary check to make sure we don't * erroneously try to free a page that wasn't * allocated. */ if (event_buffer[0] != NULL) { free_page((unsigned long) event_buffer[0]); for (i = 0; i < VIO_MAX_SUBTYPES; i++) { event_buffer[i] = NULL; } } } spin_unlock_irqrestore(&statuslock, flags); return 0; } void *vio_get_event_buffer(int subtype) { subtype = subtype >> VIOMAJOR_SUBTYPE_SHIFT; if ((subtype < 0) || (subtype >= VIO_MAX_SUBTYPES)) return NULL; if (atomic_dec_if_positive(&event_buffer_available[subtype]) == 0) return event_buffer[subtype]; else return NULL; } void vio_free_event_buffer(int subtype, void *buffer) { subtype = subtype >> VIOMAJOR_SUBTYPE_SHIFT; if ((subtype < 0) || (subtype >= VIO_MAX_SUBTYPES)) { printk(KERN_WARNING_VIO "unexpected subtype %d freeing event buffer\n", subtype); return; } if (atomic_read(&event_buffer_available[subtype]) != 0) { printk(KERN_WARNING_VIO "freeing unallocated event buffer, subtype %d\n", subtype); return; } if (buffer != event_buffer[subtype]) { printk(KERN_WARNING_VIO "freeing invalid event buffer, subtype %d\n", subtype); } atomic_set(&event_buffer_available[subtype], 1); } static const struct vio_error_entry vio_no_error = { 0, 0, "Non-VIO Error" }; static const struct vio_error_entry vio_unknown_error = { 0, EIO, "Unknown Error" }; static const struct vio_error_entry vio_default_errors[] = { {0x0001, EIO, "No Connection"}, {0x0002, EIO, "No Receiver"}, {0x0003, EIO, "No Buffer Available"}, {0x0004, EBADRQC, "Invalid Message Type"}, {0x0000, 0, NULL}, }; const struct vio_error_entry *vio_lookup_rc(const struct vio_error_entry *local_table, u16 rc) { const struct vio_error_entry *cur; if (!rc) return &vio_no_error; if (local_table) for (cur = local_table; cur->rc; ++cur) if (cur->rc == rc) return cur; for (cur = vio_default_errors; cur->rc; ++cur) if (cur->rc == rc) return cur; return &vio_unknown_error; }