/* * arch/s390/kernel/s390io.c * S/390 common I/O routines * * S390 version * Copyright (C) 1999, 2000 IBM Deutschland Entwicklung GmbH, * IBM Corporation * Author(s): Ingo Adlung (adlung@de.ibm.com) * ChangeLog: 01/04/2001 Holger Smolinski (smolinsk@de.ibm.com) * Fixed lost interrupts and do_adapter_IO */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef TRUE #define TRUE 1 #define FALSE 0 #endif #undef CONFIG_DEBUG_IO #define CONFIG_DEBUG_CRW #define REIPL_DEVID_MAGIC 0x87654321 struct s390_irqaction init_IRQ_action; unsigned int highest_subchannel; ioinfo_t *ioinfo_head = NULL; ioinfo_t *ioinfo_tail = NULL; ioinfo_t *ioinfo[__MAX_SUBCHANNELS] = { [0 ... (__MAX_SUBCHANNELS-1)] = INVALID_STORAGE_AREA }; static atomic_t sync_isc = ATOMIC_INIT(-1); // synchronous irq processing lock static spinlock_t adapter_lock = SPIN_LOCK_UNLOCKED; // adapter interrupt lock static psw_t io_sync_wait; // wait PSW for sync IO, prot. by sync_isc static int cons_dev = -1; // identify console device static int init_IRQ_complete = 0; static int cio_show_msg = 0; static schib_t *p_init_schib = NULL; static irb_t *p_init_irb = NULL; static __u64 irq_IPL_TOD; static adapter_int_handler_t adapter_handler = NULL; /* * Dummy controller type for unused interrupts */ int do_none(unsigned int irq, int cpu, struct pt_regs * regs) { return 0;} int enable_none(unsigned int irq) { return(-ENODEV); } int disable_none(unsigned int irq) { return(-ENODEV); } struct hw_interrupt_type no_irq_type = { "none", do_none, enable_none, disable_none }; static void init_IRQ_handler( int irq, void *dev_id, struct pt_regs *regs); static int s390_setup_irq(unsigned int irq, struct s390_irqaction * new); static void s390_process_subchannels( void); static void s390_device_recognition_all( void); static void s390_device_recognition_irq( int irq); static int s390_validate_subchannel( int irq, int enable); static int s390_SenseID( int irq, senseid_t *sid, __u8 lpm); static int s390_SetPGID( int irq, __u8 lpm, pgid_t *pgid); static int s390_SensePGID( int irq, __u8 lpm, pgid_t *pgid); static int s390_process_IRQ( unsigned int irq ); static int disable_subchannel( unsigned int irq); static inline void do_adapter_IO( __u32 intparm ); int s390_DevicePathVerification( int irq, __u8 domask ); int s390_register_adapter_interrupt( adapter_int_handler_t handler ); int s390_unregister_adapter_interrupt( adapter_int_handler_t handler ); extern int do_none(unsigned int irq, int cpu, struct pt_regs * regs); extern int enable_none(unsigned int irq); extern int disable_none(unsigned int irq); asmlinkage void do_IRQ( struct pt_regs regs ); void s390_displayhex(char *str,void *ptr,s32 cnt); void s390_displayhex(char *str,void *ptr,s32 cnt) { s32 cnt1,cnt2,maxcnt2; u32 *currptr=(__u32 *)ptr; printk("\n%s\n",str); for(cnt1=0;cnt116) maxcnt2=16; for(cnt2=0;cnt2irq_desc.action ) { if ( (dev_id == ioinfo[irq]->irq_desc.action->dev_id ) || (dev_id == (devstat_t *)REIPL_DEVID_MAGIC) ) { /* start deregister */ ioinfo[irq]->ui.flags.unready = 1; do { ret = disable_subchannel( irq); count++; if ( ret == -EBUSY ) { int iret; /* * kill it ! * ... we first try sync and eventually * try terminating the current I/O by * an async request, twice halt, then * clear. */ if ( count < 2 ) { iret = halt_IO( irq, 0xC8C1D3E3, DOIO_WAIT_FOR_INTERRUPT ); if ( iret == -EBUSY ) { halt_IO( irq, 0xC8C1D3E3, 0); s390irq_spin_unlock_irqrestore( irq, flags); udelay( 200000 ); /* 200 ms */ s390irq_spin_lock_irqsave( irq, flags); } /* endif */ } else { iret = clear_IO( irq, 0x40C3D3D9, DOIO_WAIT_FOR_INTERRUPT ); if ( iret == -EBUSY ) { clear_IO( irq, 0xC8C1D3E3, 0); s390irq_spin_unlock_irqrestore( irq, flags); udelay( 1000000 ); /* 1000 ms */ s390irq_spin_lock_irqsave( irq, flags); } /* endif */ } /* endif */ if ( count == 2 ) { /* give it a very last try ... */ disable_subchannel( irq); if ( ioinfo[irq]->ui.flags.busy ) { printk( KERN_CRIT"free_irq(%04X) " "- device %04X busy, retry " "count exceeded\n", irq, ioinfo[irq]->devstat.devno); } /* endif */ break; /* sigh, let's give up ... */ } /* endif */ } /* endif */ } while ( ret == -EBUSY ); if ( init_IRQ_complete ) kfree( ioinfo[irq]->irq_desc.action ); ioinfo[irq]->irq_desc.action = NULL; ioinfo[irq]->ui.flags.ready = 0; ioinfo[irq]->irq_desc.handler->enable = enable_none; ioinfo[irq]->irq_desc.handler->disable = disable_none; ioinfo[irq]->ui.flags.unready = 0; /* deregister ended */ ioinfo[irq]->nopfunc = NULL; s390irq_spin_unlock_irqrestore( irq, flags); } else { s390irq_spin_unlock_irqrestore( irq, flags); printk( "free_irq(%04X) : error, " "dev_id does not match !", irq); } /* endif */ } else { s390irq_spin_unlock_irqrestore( irq, flags); printk( "free_irq(%04X) : error, " "no action block ... !\n", irq); } /* endif */ } /* * Generic enable/disable code */ int disable_irq(unsigned int irq) { unsigned long flags; int ret; if ( ioinfo[irq] == INVALID_STORAGE_AREA ) return( -ENODEV); s390irq_spin_lock_irqsave(irq, flags); /* * At this point we may actually have a pending interrupt being active * on another CPU. So don't touch the IRQ_INPROGRESS bit.. */ ioinfo[irq]->irq_desc.status |= IRQ_DISABLED; ret = ioinfo[irq]->irq_desc.handler->disable(irq); s390irq_spin_unlock_irqrestore(irq, flags); synchronize_irq(); return( ret); } int enable_irq(unsigned int irq) { unsigned long flags; int ret; if ( ioinfo[irq] == INVALID_STORAGE_AREA ) return( -ENODEV); s390irq_spin_lock_irqsave(irq, flags); ioinfo[irq]->irq_desc.status = 0; ret = ioinfo[irq]->irq_desc.handler->enable(irq); s390irq_spin_unlock_irqrestore(irq, flags); return(ret); } /* * Enable IRQ by modifying the subchannel */ static int enable_subchannel( unsigned int irq) { int ret; int ccode; int retry = 5; if ( irq > highest_subchannel || irq < 0 ) { return( -ENODEV ); } /* endif */ if ( ioinfo[irq] == INVALID_STORAGE_AREA ) return( -ENODEV); /* * If a previous disable request is pending we reset it. However, this * status implies that the device may (still) be not-operational. */ if ( ioinfo[irq]->ui.flags.d_disable ) { ioinfo[irq]->ui.flags.d_disable = 0; ret = 0; } else { ccode = stsch(irq, &(ioinfo[irq]->schib) ); if ( ccode ) { ret = -ENODEV; } else { ioinfo[irq]->schib.pmcw.ena = 1; if ( irq == cons_dev ) { ioinfo[irq]->schib.pmcw.isc = 7; } else { ioinfo[irq]->schib.pmcw.isc = 3; } /* endif */ do { ccode = msch( irq, &(ioinfo[irq]->schib) ); switch (ccode) { case 0: ret = 0; break; case 1: /* * very bad, requires interrupt alike * processing, where "rbh" is a dummy * parameter for interface compatibility * only. Bottom-half handling cannot be * required as this must be an * unsolicited interrupt (!busy). */ ioinfo[irq]->ui.flags.s_pend = 1; s390_process_IRQ( irq ); ioinfo[irq]->ui.flags.s_pend = 0; ret = -EIO; /* might be overwritten */ /* ... on re-driving */ /* ... the msch() */ retry--; break; case 2: udelay(100); /* allow for recovery */ ret = -EBUSY; retry--; break; case 3: ioinfo[irq]->ui.flags.oper = 0; ret = -ENODEV; break; default: printk( KERN_CRIT"enable_subchannel(%04X) " " : ccode 2 on msch() for device " "%04X received !\n", irq, ioinfo[irq]->devstat.devno); ret = -ENODEV; // never reached } } while ( (ccode == 1) && retry ); } /* endif */ } /* endif */ return( ret ); } /* * Disable IRQ by modifying the subchannel */ static int disable_subchannel( unsigned int irq) { int cc; /* condition code */ int ret; /* function return value */ int retry = 5; if ( irq > highest_subchannel ) { ret = -ENODEV; } if ( ioinfo[irq] == INVALID_STORAGE_AREA ) { return( -ENODEV); } else if ( ioinfo[irq]->ui.flags.busy ) { /* * the disable function must not be called while there are * requests pending for completion ! */ ret = -EBUSY; } else { /* * If device isn't operational we have to perform delayed * disabling when the next interrupt occurs - unless the * irq is re-requested prior to the interrupt to occur. */ cc = stsch(irq, &(ioinfo[irq]->schib) ); if ( cc == 3 ) { ioinfo[irq]->ui.flags.oper = 0; ioinfo[irq]->ui.flags.d_disable = 1; ret = 0; } else // cc == 0 { ioinfo[irq]->schib.pmcw.ena = 0; do { cc = msch( irq, &(ioinfo[irq]->schib) ); switch (cc) { case 0 : ret = 0; /* done */ break; case 1 : /* * very bad, requires interrupt alike * processing, where "rbh" is a dummy * parm for interface compatibility * only. Bottom-half handling cannot * be required as this must be an * unsolicited interrupt (!busy). */ ioinfo[irq]->ui.flags.s_pend = 1; s390_process_IRQ( irq ); ioinfo[irq]->ui.flags.s_pend = 0; ret = -EIO; /* might be overwritten */ /* ... on re-driving the */ /* ... msch() call */ retry--; break; case 2 : /* * *** must not occur ! *** * *** *** * *** indicates our internal *** * *** interrupt accounting is out *** * *** of sync ===> panic() *** */ printk( KERN_CRIT"disable_subchannel(%04X) " "- unexpected busy condition for " "device %04X received !\n", irq, ioinfo[irq]->devstat.devno); ret = -EBUSY; break; case 3 : /* * should hardly occur ?! */ ioinfo[irq]->ui.flags.oper = 0; ioinfo[irq]->ui.flags.d_disable = 1; ret = 0; /* if the device has gone we */ /* ... don't need to disable */ /* ... it anymore ! */ break; default : ret = -ENODEV; // never reached ... break; } /* endswitch */ } while ( (cc == 1) && retry ); } /* endif */ } /* endif */ return( ret); } int s390_setup_irq( unsigned int irq, struct s390_irqaction * new) { unsigned long flags; int rc = 0; if ( ioinfo[irq] == INVALID_STORAGE_AREA ) { return( -ENODEV); } /* * The following block of code has to be executed atomically */ s390irq_spin_lock_irqsave( irq, flags); if ( ioinfo[irq]->irq_desc.action == NULL ) { ioinfo[irq]->irq_desc.action = new; ioinfo[irq]->irq_desc.status = 0; ioinfo[irq]->irq_desc.handler->enable = enable_subchannel; ioinfo[irq]->irq_desc.handler->disable = disable_subchannel; ioinfo[irq]->irq_desc.handler->handle = handle_IRQ_event; ioinfo[irq]->ui.flags.ready = 1; ioinfo[irq]->irq_desc.handler->enable(irq); } else { /* * interrupt already owned, and shared interrupts * aren't supported on S/390. */ rc = -EBUSY; } /* endif */ s390irq_spin_unlock_irqrestore(irq,flags); return( rc); } void s390_init_IRQ( void ) { unsigned long flags; /* PSW flags */ long cr6 __attribute__ ((aligned (8))); // Hopefully bh_count's will get set when we copy the prefix lowcore // structure to other CPI's ( DJB ) softirq_active(smp_processor_id()) = 0; softirq_mask(smp_processor_id()) = 0; local_bh_count(smp_processor_id()) = 0; local_irq_count(smp_processor_id()) = 0; syscall_count(smp_processor_id()) = 0; asm volatile ("STCK %0" : "=m" (irq_IPL_TOD)); p_init_schib = alloc_bootmem_low( sizeof(schib_t)); p_init_irb = alloc_bootmem_low( sizeof(irb_t)); /* * As we don't know about the calling environment * we assure running disabled. Before leaving the * function we resestablish the old environment. * * Note : as we don't need a system wide lock, therefore * we shouldn't use cli(), but __cli() as this * affects the current CPU only. */ __save_flags(flags); __cli(); /* * disable all interrupts */ cr6 = 0; __ctl_load( cr6, 6, 6); s390_process_subchannels(); /* * enable default I/O-interrupt sublass 3 */ cr6 = 0x10000000; __ctl_load( cr6, 6, 6); s390_device_recognition_all(); init_IRQ_complete = 1; __restore_flags(flags); return; } /* * dummy handler, used during init_IRQ() processing for compatibility only */ void init_IRQ_handler( int irq, void *dev_id, struct pt_regs *regs) { /* this is a dummy handler only ... */ } int s390_start_IO( int irq, /* IRQ */ ccw1_t *cpa, /* logical channel prog addr */ unsigned long user_intparm, /* interruption parameter */ __u8 lpm, /* logical path mask */ unsigned long flag) /* flags */ { int ccode; int ret = 0; /* * The flag usage is mutal exclusive ... */ if ( (flag & DOIO_EARLY_NOTIFICATION) && (flag & DOIO_REPORT_ALL ) ) { return( -EINVAL ); } /* endif */ /* * setup ORB */ ioinfo[irq]->orb.intparm = (__u32)(__u64)&ioinfo[irq]->u_intparm; ioinfo[irq]->orb.fmt = 1; ioinfo[irq]->orb.pfch = !(flag & DOIO_DENY_PREFETCH); ioinfo[irq]->orb.spnd = (flag & DOIO_ALLOW_SUSPEND ? TRUE : FALSE); ioinfo[irq]->orb.ssic = ( (flag & DOIO_ALLOW_SUSPEND ) && (flag & DOIO_SUPPRESS_INTER) ); if ( flag & DOIO_VALID_LPM ) { ioinfo[irq]->orb.lpm = lpm; } else { ioinfo[irq]->orb.lpm = ioinfo[irq]->opm; } /* endif */ #ifdef CONFIG_ARCH_S390X /* * for 64 bit we always support 64 bit IDAWs with 2k page * size only * FIXTHEM: OSA microcode currently has problems with 4k * we would like to use 4k. */ ioinfo[irq]->orb.c64 = 1; ioinfo[irq]->orb.i2k = 1; #endif ioinfo[irq]->orb.cpa = (__u32)virt_to_phys( cpa); /* * If sync processing was requested we lock the sync ISC, modify the * device to present interrupts for this ISC only and switch the * CPU to handle this ISC + the console ISC exclusively. */ if ( flag & DOIO_WAIT_FOR_INTERRUPT ) { ret = enable_cpu_sync_isc( irq); if ( ret ) { return( ret); } } /* endif */ if ( flag & DOIO_DONT_CALL_INTHDLR ) { ioinfo[irq]->ui.flags.repnone = 1; } /* endif */ /* * Issue "Start subchannel" and process condition code */ ccode = ssch( irq, &(ioinfo[irq]->orb) ); switch ( ccode ) { case 0: if ( !ioinfo[irq]->ui.flags.w4sense ) { /* * init the device driver specific devstat irb area * * Note : donīt clear saved irb info in case of sense ! */ memset( &((devstat_t *)ioinfo[irq]->irq_desc.action->dev_id)->ii.irb, '\0', sizeof( irb_t) ); } /* endif */ memset( &ioinfo[irq]->devstat.ii.irb, '\0', sizeof( irb_t) ); /* * initialize device status information */ ioinfo[irq]->ui.flags.busy = 1; ioinfo[irq]->ui.flags.doio = 1; ioinfo[irq]->u_intparm = user_intparm; ioinfo[irq]->devstat.cstat = 0; ioinfo[irq]->devstat.dstat = 0; ioinfo[irq]->devstat.lpum = 0; ioinfo[irq]->devstat.flag = DEVSTAT_START_FUNCTION; ioinfo[irq]->devstat.scnt = 0; ioinfo[irq]->ui.flags.fast = 0; ioinfo[irq]->ui.flags.repall = 0; /* * Check for either early (FAST) notification requests * or if we are to return all interrupt info. * Default is to call IRQ handler at secondary status only */ if ( flag & DOIO_EARLY_NOTIFICATION ) { ioinfo[irq]->ui.flags.fast = 1; } else if ( flag & DOIO_REPORT_ALL ) { ioinfo[irq]->ui.flags.repall = 1; } /* endif */ ioinfo[irq]->ulpm = ioinfo[irq]->orb.lpm; /* * If synchronous I/O processing is requested, we have * to wait for the corresponding interrupt to occur by * polling the interrupt condition. However, as multiple * interrupts may be outstanding, we must not just wait * for the first interrupt, but must poll until ours * pops up. */ if ( flag & DOIO_WAIT_FOR_INTERRUPT ) { psw_t io_new_psw; int ccode; uint64_t time_start; uint64_t time_curr; int ready = 0; int io_sub = -1; struct _lowcore *lc = NULL; int do_retry = 1; /* * We shouldn't perform a TPI loop, waiting for an * interrupt to occur, but should load a WAIT PSW * instead. Otherwise we may keep the channel subsystem * busy, not able to present the interrupt. When our * sync. interrupt arrived we reset the I/O old PSW to * its original value. */ memcpy( &io_new_psw, &lc->io_new_psw, sizeof(psw_t)); ccode = iac(); switch (ccode) { case 0: // primary-space io_sync_wait.mask = _IO_PSW_MASK | _PSW_PRIM_SPACE_MODE | _PSW_IO_WAIT; break; case 1: // secondary-space io_sync_wait.mask = _IO_PSW_MASK | _PSW_SEC_SPACE_MODE | _PSW_IO_WAIT; break; case 2: // access-register io_sync_wait.mask = _IO_PSW_MASK | _PSW_ACC_REG_MODE | _PSW_IO_WAIT; break; case 3: // home-space io_sync_wait.mask = _IO_PSW_MASK | _PSW_HOME_SPACE_MODE | _PSW_IO_WAIT; break; default: panic( "start_IO() : unexpected " "address-space-control %d\n", ccode); break; } /* endswitch */ io_sync_wait.addr = FIX_PSW(&&io_wakeup); /* * Martin didn't like modifying the new PSW, now we take * a fast exit in do_IRQ() instead */ *(__u32 *)__LC_SYNC_IO_WORD = 1; asm volatile ("STCK %0" : "=m" (time_start)); time_start = time_start >> 32; do { if ( flag & DOIO_TIMEOUT ) { tpi_info_t tpi_info={0,}; do { if ( tpi(&tpi_info) == 1 ) { io_sub = tpi_info.irq; break; } else { udelay(100); /* usecs */ asm volatile ("STCK %0" : "=m" (time_curr)); if ( ((time_curr >> 32) - time_start ) >= 3 ) do_retry = 0; } /* endif */ } while ( do_retry ); } else { __load_psw( io_sync_wait ); io_wakeup: io_sub = (__u32)*(__u16 *)__LC_SUBCHANNEL_NR; } /* endif */ if ( do_retry ) ready = s390_process_IRQ( io_sub ); /* * surrender when retry count's exceeded ... */ } while ( !( ( io_sub == irq ) && ( ready == 1 )) && do_retry ); *(__u32 *)__LC_SYNC_IO_WORD = 0; if ( !do_retry ) ret = -ETIMEDOUT; } /* endif */ break; case 1 : /* status pending */ ioinfo[irq]->devstat.flag = DEVSTAT_START_FUNCTION | DEVSTAT_STATUS_PENDING; /* * initialize the device driver specific devstat irb area */ memset( &((devstat_t *) ioinfo[irq]->irq_desc.action->dev_id)->ii.irb, '\0', sizeof( irb_t) ); /* * Let the common interrupt handler process the pending status. * However, we must avoid calling the user action handler, as * it won't be prepared to handle a pending status during * do_IO() processing inline. This also implies that process_IRQ * must terminate synchronously - especially if device sensing * is required. */ ioinfo[irq]->ui.flags.s_pend = 1; ioinfo[irq]->ui.flags.busy = 1; ioinfo[irq]->ui.flags.doio = 1; s390_process_IRQ( irq ); ioinfo[irq]->ui.flags.s_pend = 0; ioinfo[irq]->ui.flags.busy = 0; ioinfo[irq]->ui.flags.doio = 0; ioinfo[irq]->ui.flags.repall = 0; ioinfo[irq]->ui.flags.w4final = 0; ioinfo[irq]->devstat.flag |= DEVSTAT_FINAL_STATUS; /* * In multipath mode a condition code 3 implies the last path * has gone, except we have previously restricted the I/O to * a particular path. A condition code 1 (0 won't occur) * results in return code EIO as well as 3 with another path * than the one used (i.e. path available mask is non-zero). */ if ( ioinfo[irq]->devstat.ii.irb.scsw.cc == 3 ) { if ( flag & DOIO_VALID_LPM ) { ioinfo[irq]->opm &= ~(ioinfo[irq]->devstat.ii.irb.esw.esw1.lpum); } else { ioinfo[irq]->opm = 0; } /* endif */ if ( ioinfo[irq]->opm == 0 ) { ret = -ENODEV; ioinfo[irq]->ui.flags.oper = 0; } else { ret = -EIO; } /* endif */ ioinfo[irq]->devstat.flag |= DEVSTAT_NOT_OPER; #ifdef CONFIG_DEBUG_IO { char buffer[80]; stsch(irq, &(ioinfo[irq]->schib) ); sprintf( buffer, "s390_start_IO(%04X) - irb for " "device %04X, after status pending\n", irq, ioinfo[irq]->devstat.devno ); s390_displayhex( buffer, &(ioinfo[irq]->devstat.ii.irb) , sizeof(irb_t)); sprintf( buffer, "s390_start_IO(%04X) - schib for " "device %04X, after status pending\n", irq, ioinfo[irq]->devstat.devno ); s390_displayhex( buffer, &(ioinfo[irq]->schib) , sizeof(schib_t)); if (ioinfo[irq]->devstat.flag & DEVSTAT_FLAG_SENSE_AVAIL) { sprintf( buffer, "s390_start_IO(%04X) - sense " "data for " "device %04X, after status pending\n", irq, ioinfo[irq]->devstat.devno ); s390_displayhex( buffer, ((devstat_t *)(ioinfo[irq]->irq_desc.action->dev_id))->ii.sense.data, ((devstat_t *)(ioinfo[irq]->irq_desc.action->dev_id))->rescnt); } /* endif */ } #endif } else { ret = -EIO; ioinfo[irq]->devstat.flag &= ~DEVSTAT_NOT_OPER; ioinfo[irq]->ui.flags.oper = 1; } /* endif */ break; case 2 : /* busy */ ret = -EBUSY; break; default: /* device/path not operational */ if ( flag & DOIO_VALID_LPM ) { ioinfo[irq]->opm &= ~lpm; } else { ioinfo[irq]->opm = 0; } /* endif */ if ( ioinfo[irq]->opm == 0 ) { ioinfo[irq]->ui.flags.oper = 0; ioinfo[irq]->devstat.flag |= DEVSTAT_NOT_OPER; } /* endif */ ret = -ENODEV; memcpy( ioinfo[irq]->irq_desc.action->dev_id, &(ioinfo[irq]->devstat), sizeof( devstat_t) ); #ifdef CONFIG_DEBUG_IO { char buffer[80]; stsch(irq, &(ioinfo[irq]->schib) ); sprintf( buffer, "s390_start_IO(%04X) - schib for " "device %04X, after 'not oper' status\n", irq, ioinfo[irq]->devstat.devno ); s390_displayhex( buffer, &(ioinfo[irq]->schib), sizeof(schib_t)); } #endif break; } /* endswitch */ if ( flag & DOIO_WAIT_FOR_INTERRUPT) { disable_cpu_sync_isc( irq ); } /* endif */ if ( flag & DOIO_DONT_CALL_INTHDLR ) { ioinfo[irq]->ui.flags.repnone = 0; } /* endif */ return( ret); } int do_IO( int irq, /* IRQ */ ccw1_t *cpa, /* channel program address */ unsigned long user_intparm, /* interruption parameter */ __u8 lpm, /* logical path mask */ unsigned long flag) /* flags : see above */ { int ret = 0; if ( irq > highest_subchannel || irq < 0 ) { return( -ENODEV ); } /* endif */ if ( ioinfo[irq] == INVALID_STORAGE_AREA ) { return( -ENODEV); } /* handler registered ? or free_irq() in process already ? */ if ( !ioinfo[irq]->ui.flags.ready || ioinfo[irq]->ui.flags.unready ) { return( -ENODEV ); } /* endif */ /* * Note: We ignore the device operational status - if not operational, * the SSCH will lead to an -ENODEV condition ... */ if ( !ioinfo[irq]->ui.flags.busy ) /* last I/O completed ? */ { ret = s390_start_IO( irq, cpa, user_intparm, lpm, flag); } else if ( ioinfo[irq]->ui.flags.fast ) { /* * If primary status was received and ending status is missing, * the device driver won't be notified on the ending status * if early (fast) interrupt notification was requested. * Therefore we have to queue the next incoming request. If * halt_IO() is issued while there is a request queued, a HSCH * needs to be issued and the queued request must be deleted * but its intparm must be returned (see halt_IO() processing) */ if ( ioinfo[irq]->ui.flags.w4final && !ioinfo[irq]->ui.flags.doio_q ) { ioinfo[irq]->qflag = flag; ioinfo[irq]->qcpa = cpa; ioinfo[irq]->qintparm = user_intparm; ioinfo[irq]->qlpm = lpm; } else { ret = -EBUSY; } /* endif */ } else { ret = -EBUSY; } /* endif */ return( ret ); } /* * resume suspended I/O operation */ int resume_IO( int irq) { int ret = 0; if ( irq > highest_subchannel || irq < 0 ) { return( -ENODEV ); } /* endif */ if ( ioinfo[irq] == INVALID_STORAGE_AREA ) { return( -ENODEV); } /* * We allow for 'resume' requests only for active I/O operations */ if ( ioinfo[irq]->ui.flags.busy ) { int ccode; ccode = rsch( irq); switch (ccode) { case 0 : break; case 1 : s390_process_IRQ( irq ); ret = -EBUSY; break; case 2 : ret = -EINVAL; break; case 3 : /* * useless to wait for request completion * as device is no longer operational ! */ ioinfo[irq]->ui.flags.oper = 0; ioinfo[irq]->ui.flags.busy = 0; ret = -ENODEV; break; } /* endswitch */ } else { ret = -ENOTCONN; } /* endif */ return( ret); } /* * Note: The "intparm" parameter is not used by the halt_IO() function * itself, as no ORB is built for the HSCH instruction. However, * it allows the device interrupt handler to associate the upcoming * interrupt with the halt_IO() request. */ int halt_IO( int irq, unsigned long user_intparm, unsigned long flag) /* possible DOIO_WAIT_FOR_INTERRUPT */ { int ret; int ccode; if ( irq > highest_subchannel || irq < 0 ) { ret = -ENODEV; } if ( ioinfo[irq] == INVALID_STORAGE_AREA ) { return( -ENODEV); } /* * we only allow for halt_IO if the device has an I/O handler associated */ else if ( !ioinfo[irq]->ui.flags.ready ) { ret = -ENODEV; } /* * we ignore the halt_io() request if ending_status was received but * a SENSE operation is waiting for completion. */ else if ( ioinfo[irq]->ui.flags.w4sense ) { ret = 0; } /* * We don't allow for halt_io with a sync do_IO() requests pending. */ else if ( ioinfo[irq]->ui.flags.syncio && (flag & DOIO_WAIT_FOR_INTERRUPT)) { ret = -EBUSY; } else { /* * If sync processing was requested we lock the sync ISC, * modify the device to present interrupts for this ISC only * and switch the CPU to handle this ISC + the console ISC * exclusively. */ if ( flag & DOIO_WAIT_FOR_INTERRUPT ) { ret = enable_cpu_sync_isc( irq); if ( ret ) { return( ret); } /* endif */ } /* endif */ /* * Issue "Halt subchannel" and process condition code */ ccode = hsch( irq ); switch ( ccode ) { case 0: ioinfo[irq]->ui.flags.haltio = 1; if ( !ioinfo[irq]->ui.flags.doio ) { ioinfo[irq]->ui.flags.busy = 1; ioinfo[irq]->u_intparm = user_intparm; ioinfo[irq]->devstat.cstat = 0; ioinfo[irq]->devstat.dstat = 0; ioinfo[irq]->devstat.lpum = 0; ioinfo[irq]->devstat.flag = DEVSTAT_HALT_FUNCTION; ioinfo[irq]->devstat.scnt = 0; } else { ioinfo[irq]->devstat.flag |= DEVSTAT_HALT_FUNCTION; } /* endif */ /* * If synchronous I/O processing is requested, we have * to wait for the corresponding interrupt to occur by * polling the interrupt condition. However, as multiple * interrupts may be outstanding, we must not just wait * for the first interrupt, but must poll until ours * pops up. */ if ( flag & DOIO_WAIT_FOR_INTERRUPT ) { int io_sub; __u32 io_parm; psw_t io_new_psw; int ccode; int ready = 0; struct _lowcore *lc = NULL; /* * We shouldn't perform a TPI loop, waiting for * an interrupt to occur, but should load a * WAIT PSW instead. Otherwise we may keep the * channel subsystem busy, not able to present * the interrupt. When our sync. interrupt * arrived we reset the I/O old PSW to its * original value. */ memcpy( &io_new_psw, &lc->io_new_psw, sizeof(psw_t)); ccode = iac(); switch (ccode) { case 0: // primary-space io_sync_wait.mask = _IO_PSW_MASK | _PSW_PRIM_SPACE_MODE | _PSW_IO_WAIT; break; case 1: // secondary-space io_sync_wait.mask = _IO_PSW_MASK | _PSW_SEC_SPACE_MODE | _PSW_IO_WAIT; break; case 2: // access-register io_sync_wait.mask = _IO_PSW_MASK | _PSW_ACC_REG_MODE | _PSW_IO_WAIT; break; case 3: // home-space io_sync_wait.mask = _IO_PSW_MASK | _PSW_HOME_SPACE_MODE | _PSW_IO_WAIT; break; default: panic( "halt_IO() : unexpected " "address-space-control %d\n", ccode); break; } /* endswitch */ io_sync_wait.addr = FIX_PSW(&&hio_wakeup); /* * Martin didn't like modifying the new PSW, now we take * a fast exit in do_IRQ() instead */ *(__u32 *)__LC_SYNC_IO_WORD = 1; do { __load_psw( io_sync_wait ); hio_wakeup: io_parm = *(__u32 *)__LC_IO_INT_PARM; io_sub = (__u32)*(__u16 *)__LC_SUBCHANNEL_NR; ready = s390_process_IRQ( io_sub ); } while ( !((io_sub == irq) && (ready == 1)) ); *(__u32 *)__LC_SYNC_IO_WORD = 0; } /* endif */ ret = 0; break; case 1 : /* status pending */ ioinfo[irq]->devstat.flag |= DEVSTAT_STATUS_PENDING; /* * initialize the device driver specific devstat irb area */ memset( &((devstat_t *) ioinfo[irq]->irq_desc.action->dev_id)->ii.irb, '\0', sizeof( irb_t) ); /* * Let the common interrupt handler process the pending * status. However, we must avoid calling the user * action handler, as it won't be prepared to handle * a pending status during do_IO() processing inline. * This also implies that s390_process_IRQ must * terminate synchronously - especially if device * sensing is required. */ ioinfo[irq]->ui.flags.s_pend = 1; ioinfo[irq]->ui.flags.busy = 1; ioinfo[irq]->ui.flags.doio = 1; s390_process_IRQ( irq ); ioinfo[irq]->ui.flags.s_pend = 0; ioinfo[irq]->ui.flags.busy = 0; ioinfo[irq]->ui.flags.doio = 0; ioinfo[irq]->ui.flags.repall = 0; ioinfo[irq]->ui.flags.w4final = 0; ioinfo[irq]->devstat.flag |= DEVSTAT_FINAL_STATUS; /* * In multipath mode a condition code 3 implies the last * path has gone, except we have previously restricted * the I/O to a particular path. A condition code 1 * (0 won't occur) results in return code EIO as well * as 3 with another path than the one used (i.e. path available mask is non-zero). */ if ( ioinfo[irq]->devstat.ii.irb.scsw.cc == 3 ) { ret = -ENODEV; ioinfo[irq]->devstat.flag |= DEVSTAT_NOT_OPER; ioinfo[irq]->ui.flags.oper = 0; } else { ret = -EIO; ioinfo[irq]->devstat.flag &= ~DEVSTAT_NOT_OPER; ioinfo[irq]->ui.flags.oper = 1; } /* endif */ break; case 2 : /* busy */ ret = -EBUSY; break; default: /* device not operational */ ret = -ENODEV; break; } /* endswitch */ if ( flag & DOIO_WAIT_FOR_INTERRUPT ) { disable_cpu_sync_isc( irq ); } /* endif */ } /* endif */ return( ret ); } /* * Note: The "intparm" parameter is not used by the clear_IO() function * itself, as no ORB is built for the CSCH instruction. However, * it allows the device interrupt handler to associate the upcoming * interrupt with the clear_IO() request. */ int clear_IO( int irq, unsigned long user_intparm, unsigned long flag) /* possible DOIO_WAIT_FOR_INTERRUPT */ { int ret; int ccode; if ( irq > highest_subchannel || irq < 0 ) { ret = -ENODEV; } if ( ioinfo[irq] == INVALID_STORAGE_AREA ) { return( -ENODEV); } /* * we only allow for halt_IO if the device has an I/O handler associated */ else if ( !ioinfo[irq]->ui.flags.ready ) { ret = -ENODEV; } /* * we ignore the halt_io() request if ending_status was received but * a SENSE operation is waiting for completion. */ else if ( ioinfo[irq]->ui.flags.w4sense ) { ret = 0; } /* * We don't allow for halt_io with a sync do_IO() requests pending. * Concurrent I/O is possible in SMP environments only, but the * sync. I/O request can be gated to one CPU at a time only. */ else if ( ioinfo[irq]->ui.flags.syncio ) { ret = -EBUSY; } else { /* * If sync processing was requested we lock the sync ISC, * modify the device to present interrupts for this ISC only * and switch the CPU to handle this ISC + the console ISC * exclusively. */ if ( flag & DOIO_WAIT_FOR_INTERRUPT ) { ret = enable_cpu_sync_isc( irq); if ( ret ) { return( ret); } /* endif */ } /* endif */ /* * Issue "Halt subchannel" and process condition code */ ccode = csch( irq ); switch ( ccode ) { case 0: ioinfo[irq]->ui.flags.haltio = 1; if ( !ioinfo[irq]->ui.flags.doio ) { ioinfo[irq]->ui.flags.busy = 1; ioinfo[irq]->u_intparm = user_intparm; ioinfo[irq]->devstat.cstat = 0; ioinfo[irq]->devstat.dstat = 0; ioinfo[irq]->devstat.lpum = 0; ioinfo[irq]->devstat.flag = DEVSTAT_CLEAR_FUNCTION; ioinfo[irq]->devstat.scnt = 0; } else { ioinfo[irq]->devstat.flag |= DEVSTAT_CLEAR_FUNCTION; } /* endif */ /* * If synchronous I/O processing is requested, we have * to wait for the corresponding interrupt to occur by * polling the interrupt condition. However, as multiple * interrupts may be outstanding, we must not just wait * for the first interrupt, but must poll until ours * pops up. */ if ( flag & DOIO_WAIT_FOR_INTERRUPT ) { int io_sub; __u32 io_parm; psw_t io_new_psw; int ccode; int ready = 0; struct _lowcore *lc = NULL; /* * We shouldn't perform a TPI loop, waiting for * an interrupt to occur, but should load a * WAIT PSW instead. Otherwise we may keep the * channel subsystem busy, not able to present * the interrupt. When our sync. interrupt * arrived we reset the I/O old PSW to its * original value. */ memcpy( &io_new_psw, &lc->io_new_psw, sizeof(psw_t)); ccode = iac(); switch (ccode) { case 0: // primary-space io_sync_wait.mask = _IO_PSW_MASK | _PSW_PRIM_SPACE_MODE | _PSW_IO_WAIT; break; case 1: // secondary-space io_sync_wait.mask = _IO_PSW_MASK | _PSW_SEC_SPACE_MODE | _PSW_IO_WAIT; break; case 2: // access-register io_sync_wait.mask = _IO_PSW_MASK | _PSW_ACC_REG_MODE | _PSW_IO_WAIT; break; case 3: // home-space io_sync_wait.mask = _IO_PSW_MASK | _PSW_HOME_SPACE_MODE | _PSW_IO_WAIT; break; default: panic( "halt_IO() : unexpected " "address-space-control %d\n", ccode); break; } /* endswitch */ io_sync_wait.addr = FIX_PSW(&&cio_wakeup); /* * Martin didn't like modifying the new PSW, now we take * a fast exit in do_IRQ() instead */ *(__u32 *)__LC_SYNC_IO_WORD = 1; do { __load_psw( io_sync_wait ); cio_wakeup: io_parm = *(__u32 *)__LC_IO_INT_PARM; io_sub = (__u32)*(__u16 *)__LC_SUBCHANNEL_NR; ready = s390_process_IRQ( io_sub ); } while ( !((io_sub == irq) && (ready == 1)) ); *(__u32 *)__LC_SYNC_IO_WORD = 0; } /* endif */ ret = 0; break; case 1 : /* status pending */ ioinfo[irq]->devstat.flag |= DEVSTAT_STATUS_PENDING; /* * initialize the device driver specific devstat irb area */ memset( &((devstat_t *) ioinfo[irq]->irq_desc.action->dev_id)->ii.irb, '\0', sizeof( irb_t) ); /* * Let the common interrupt handler process the pending * status. However, we must avoid calling the user * action handler, as it won't be prepared to handle * a pending status during do_IO() processing inline. * This also implies that s390_process_IRQ must * terminate synchronously - especially if device * sensing is required. */ ioinfo[irq]->ui.flags.s_pend = 1; ioinfo[irq]->ui.flags.busy = 1; ioinfo[irq]->ui.flags.doio = 1; s390_process_IRQ( irq ); ioinfo[irq]->ui.flags.s_pend = 0; ioinfo[irq]->ui.flags.busy = 0; ioinfo[irq]->ui.flags.doio = 0; ioinfo[irq]->ui.flags.repall = 0; ioinfo[irq]->ui.flags.w4final = 0; ioinfo[irq]->devstat.flag |= DEVSTAT_FINAL_STATUS; /* * In multipath mode a condition code 3 implies the last * path has gone, except we have previously restricted * the I/O to a particular path. A condition code 1 * (0 won't occur) results in return code EIO as well * as 3 with another path than the one used (i.e. path available mask is non-zero). */ if ( ioinfo[irq]->devstat.ii.irb.scsw.cc == 3 ) { ret = -ENODEV; ioinfo[irq]->devstat.flag |= DEVSTAT_NOT_OPER; ioinfo[irq]->ui.flags.oper = 0; } else { ret = -EIO; ioinfo[irq]->devstat.flag &= ~DEVSTAT_NOT_OPER; ioinfo[irq]->ui.flags.oper = 1; } /* endif */ break; case 2 : /* busy */ ret = -EBUSY; break; default: /* device not operational */ ret = -ENODEV; break; } /* endswitch */ if ( flag & DOIO_WAIT_FOR_INTERRUPT ) { disable_cpu_sync_isc( irq ); } /* endif */ } /* endif */ return( ret ); } /* * do_IRQ() handles all normal I/O device IRQ's (the special * SMP cross-CPU interrupts have their own specific * handlers). * */ asmlinkage void do_IRQ( struct pt_regs regs ) { /* * Get interrupt info from lowcore */ volatile tpi_info_t *tpi_info = (tpi_info_t*)(__LC_SUBCHANNEL_ID); /* * take fast exit if CPU is in sync. I/O state * * Note: we have to turn off the WAIT bit and re-disable * interrupts prior to return as this was the initial * entry condition to synchronous I/O. */ if ( *(__u32 *)__LC_SYNC_IO_WORD ) { regs.psw.mask &= ~(_PSW_WAIT_MASK_BIT | _PSW_IO_MASK_BIT); return; } /* endif */ #ifdef CONFIG_FAST_IRQ do { #endif /* CONFIG_FAST_IRQ */ /* * Non I/O-subchannel thin interrupts are processed differently */ if ( tpi_info->adapter_IO == 1 && tpi_info->int_type == IO_INTERRUPT_TYPE ) { do_adapter_IO( tpi_info->intparm ); } else { unsigned int irq = tpi_info->irq; /* * fix me !!! * * instead of boxing the device, we need to schedule device * recognition, the interrupt stays pending. We need to * dynamically allocate an ioinfo structure, etc.. */ if ( ioinfo[irq] == INVALID_STORAGE_AREA ) { return; /* this keeps the device boxed ... */ } s390irq_spin_lock( irq ); s390_process_IRQ( irq ); s390irq_spin_unlock( irq ); } #ifdef CONFIG_FAST_IRQ /* * Are more interrupts pending? * If so, the tpi instruction will update the lowcore * to hold the info for the next interrupt. */ } while ( tpi( NULL ) != 0 ); #endif /* CONFIG_FAST_IRQ */ return; } /* * s390_process_IRQ() handles status pending situations and interrupts * * Called by : do_IRQ() - for "real" interrupts * s390_start_IO, halt_IO() * - status pending cond. after SSCH, or HSCH * disable_subchannel() - status pending conditions (after MSCH) * * Returns: 0 - no ending status received, no further action taken * 1 - interrupt handler was called with ending status */ int s390_process_IRQ( unsigned int irq ) { int ccode; /* cond code from tsch() operation */ int irb_cc; /* cond code from irb */ int sdevstat; /* struct devstat size to copy */ unsigned int fctl; /* function control */ unsigned int stctl; /* status control */ unsigned int actl; /* activity control */ struct s390_irqaction *action; struct pt_regs regs; /* for interface compatibility only */ int issense = 0; int ending_status = 0; int allow4handler = 1; int chnchk = 0; devstat_t *dp; #if 0 int cpu = smp_processor_id(); kstat.irqs[cpu][irq]++; #endif if ( ioinfo[irq] == INVALID_STORAGE_AREA ) { /* we can't properly process the interrupt ... */ tsch( irq, p_init_irb ); return( 1 ); } /* endif */ action = ioinfo[irq]->irq_desc.action; dp = &ioinfo[irq]->devstat; #ifdef CONFIG_DEBUG_IO /* * It might be possible that a device was not-oper. at the time * of free_irq() processing. This means the handler is no longer * available when the device possibly becomes ready again. In * this case we perform delayed disable_subchannel() processing. */ if ( action == NULL ) { if ( !ioinfo[irq]->ui.flags.d_disable ) { printk( KERN_CRIT"s390_process_IRQ(%04X) " "- no interrupt handler registered " "for device %04X !\n", irq, ioinfo[irq]->devstat.devno); } /* endif */ } /* endif */ #endif /* * retrieve the i/o interrupt information (irb), * update the device specific status information * and possibly call the interrupt handler. * * Note 1: At this time we don't process the resulting * condition code (ccode) from tsch(), although * we probably should. * * Note 2: Here we will have to check for channel * check conditions and call a channel check * handler. * * Note 3: If a start function was issued, the interruption * parameter relates to it. If a halt function was * issued for an idle device, the intparm must not * be taken from lowcore, but from the devstat area. */ ccode = tsch( irq, &(dp->ii.irb) ); // // We must only accumulate the status if the device is busy already // if ( ioinfo[irq]->ui.flags.busy ) { dp->dstat |= dp->ii.irb.scsw.dstat; dp->cstat |= dp->ii.irb.scsw.cstat; dp->intparm = ioinfo[irq]->u_intparm; } else { dp->dstat = dp->ii.irb.scsw.dstat; dp->cstat = dp->ii.irb.scsw.cstat; dp->flag = 0; // reset status flags dp->intparm = 0; } /* endif */ dp->lpum = dp->ii.irb.esw.esw1.lpum; /* * reset device-busy bit if no longer set in irb */ if ( (dp->dstat & DEV_STAT_BUSY ) && ((dp->ii.irb.scsw.dstat & DEV_STAT_BUSY) == 0)) { dp->dstat &= ~DEV_STAT_BUSY; } /* endif */ /* * Save residual count and CCW information in case primary and * secondary status are presented with different interrupts. */ if ( dp->ii.irb.scsw.stctl & ( SCSW_STCTL_PRIM_STATUS | SCSW_STCTL_INTER_STATUS ) ) { dp->rescnt = dp->ii.irb.scsw.count; dp->cpa = dp->ii.irb.scsw.cpa; #ifdef CONFIG_DEBUG_IO if ( irq != cons_dev ) printk( "s390_process_IRQ( %04X ) : " "residual count from irb after tsch() %d\n", irq, dp->rescnt ); #endif } /* endif */ irb_cc = dp->ii.irb.scsw.cc; // // check for any kind of channel or interface control check but don't // issue the message for the console device // if ( (dp->ii.irb.scsw.cstat & ( SCHN_STAT_CHN_DATA_CHK | SCHN_STAT_CHN_CTRL_CHK | SCHN_STAT_INTF_CTRL_CHK ) ) && (irq != cons_dev ) ) { printk( "Channel-Check or Interface-Control-Check " "received\n" " ... device %04X on subchannel %04X, dev_stat " ": %02X sch_stat : %02X\n", ioinfo[irq]->devstat.devno, irq, dp->dstat, dp->cstat); chnchk = 1; } /* endif */ if ( (dp->ii.irb.scsw.stctl == SCSW_STCTL_STATUS_PEND) && (dp->ii.irb.scsw.eswf == 0 )) { issense = 0; } else if ( (dp->ii.irb.scsw.stctl == (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_INTER_STATUS)) && ((dp->ii.irb.scsw.actl & SCSW_ACTL_SUSPENDED) == 0)) { issense = 0; } else { issense = dp->ii.irb.esw.esw0.erw.cons; } /* endif */ if ( issense ) { dp->scnt = dp->ii.irb.esw.esw0.erw.scnt; dp->flag |= DEVSTAT_FLAG_SENSE_AVAIL; sdevstat = sizeof( devstat_t); #ifdef CONFIG_DEBUG_IO if ( irq != cons_dev ) printk( "s390_process_IRQ( %04X ) : " "concurrent sense bytes avail %d\n", irq, dp->scnt ); #endif } else { /* don't copy the sense data area ! */ sdevstat = sizeof( devstat_t) - SENSE_MAX_COUNT; } /* endif */ switch ( irb_cc ) { case 1: /* status pending */ dp->flag |= DEVSTAT_STATUS_PENDING; case 0: /* normal i/o interruption */ fctl = dp->ii.irb.scsw.fctl; stctl = dp->ii.irb.scsw.stctl; actl = dp->ii.irb.scsw.actl; if ( chnchk ) { char buffer[80]; sprintf( buffer, "s390_process_IRQ(%04X) - irb for " "device %04X after channel check\n", irq, dp->devno ); s390_displayhex( buffer, &(dp->ii.irb) , sizeof(irb_t)); } /* endif */ ioinfo[irq]->stctl |= stctl; ending_status = ( stctl & SCSW_STCTL_SEC_STATUS ) || ( stctl == (SCSW_STCTL_ALERT_STATUS | SCSW_STCTL_STATUS_PEND) ) || ( (fctl == SCSW_FCTL_HALT_FUNC) && (stctl == SCSW_STCTL_STATUS_PEND) ) || ( (fctl == SCSW_FCTL_CLEAR_FUNC) && (stctl == SCSW_STCTL_STATUS_PEND) ); /* * Check for unsolicited interrupts - for debug purposes only * * We only consider an interrupt as unsolicited, if the device was not * actively in use (busy) and an interrupt other than an ALERT status * was received. * * Note: We must not issue a message to the console, if the * unsolicited interrupt applies to the console device * itself ! */ #ifdef CONFIG_DEBUG_IO if ( ( irq != cons_dev ) && !( stctl & SCSW_STCTL_ALERT_STATUS ) && ( ioinfo[irq]->ui.flags.busy == 0 ) ) { char buffer[80]; printk( "Unsolicited interrupt received for device %04X on subchannel %04X\n" " ... device status : %02X subchannel status : %02X\n", dp->devno, irq, dp->dstat, dp->cstat); sprintf( buffer, "s390_process_IRQ(%04X) - irb for " "device %04X, ending_status %d\n", irq, dp->devno, ending_status); s390_displayhex( buffer, &(dp->ii.irb) , sizeof(irb_t)); } /* endif */ #endif /* * take fast exit if no handler is available */ if ( !action ) return( ending_status ); /* * Check whether we must issue a SENSE CCW ourselves if there is no * concurrent sense facility installed for the subchannel. * * Note: We should check for ioinfo[irq]->ui.flags.consns but VM * violates the ESA/390 architecture and doesn't present an * operand exception for virtual devices without concurrent * sense facility available/supported when enabling the * concurrent sense facility. */ if ( ( (dp->ii.irb.scsw.dstat & DEV_STAT_UNIT_CHECK ) && (!issense ) ) || (ioinfo[irq]->ui.flags.delsense && ending_status ) ) { int ret_io; ccw1_t *s_ccw = &ioinfo[irq]->senseccw; unsigned long s_flag = 0; if ( ending_status ) { /* * We copy the current status information into the device driver * status area. Then we can use the local devstat area for device * sensing. When finally calling the IRQ handler we must not overlay * the original device status but copy the sense data only. */ memcpy( action->dev_id, dp, sizeof( devstat_t) ); s_ccw->cmd_code = CCW_CMD_BASIC_SENSE; s_ccw->cda = (__u32)virt_to_phys( ioinfo[irq]->sense_data ); s_ccw->count = SENSE_MAX_COUNT; s_ccw->flags = CCW_FLAG_SLI; /* * If free_irq() or a sync do_IO/s390_start_IO() is in * process we have to sense synchronously */ if ( ioinfo[irq]->ui.flags.unready || ioinfo[irq]->ui.flags.syncio ) { s_flag = DOIO_WAIT_FOR_INTERRUPT; } /* endif */ /* * Reset status info * * It does not matter whether this is a sync. or async. * SENSE request, but we have to assure we don't call * the irq handler now, but keep the irq in busy state. * In sync. mode s390_process_IRQ() is called recursively, * while in async. mode we re-enter do_IRQ() with the * next interrupt. * * Note : this may be a delayed sense request ! */ allow4handler = 0; ioinfo[irq]->ui.flags.fast = 0; ioinfo[irq]->ui.flags.repall = 0; ioinfo[irq]->ui.flags.w4final = 0; ioinfo[irq]->ui.flags.delsense = 0; dp->cstat = 0; dp->dstat = 0; dp->rescnt = SENSE_MAX_COUNT; ioinfo[irq]->ui.flags.w4sense = 1; ret_io = s390_start_IO( irq, s_ccw, 0xE2C5D5E2, // = SENSe 0, // n/a s_flag); } else { /* * we received an Unit Check but we have no final * status yet, therefore we must delay the SENSE * processing. However, we must not report this * intermediate status to the device interrupt * handler. */ ioinfo[irq]->ui.flags.fast = 0; ioinfo[irq]->ui.flags.repall = 0; ioinfo[irq]->ui.flags.delsense = 1; allow4handler = 0; } /* endif */ } /* endif */ /* * we allow for the device action handler if . * - we received ending status * - the action handler requested to see all interrupts * - we received an intermediate status * - fast notification was requested (primary status) * - unsollicited interrupts * */ if ( allow4handler ) { allow4handler = ending_status || ( ioinfo[irq]->ui.flags.repall ) || ( stctl & SCSW_STCTL_INTER_STATUS ) || ( (ioinfo[irq]->ui.flags.fast ) && (stctl & SCSW_STCTL_PRIM_STATUS) ) || ( ioinfo[irq]->ui.flags.oper == 0 ); } /* endif */ /* * We used to copy the device status information right before * calling the device action handler. However, in status * pending situations during do_IO() or halt_IO(), as well as * enable_subchannel/disable_subchannel processing we must * synchronously return the status information and must not * call the device action handler. * */ if ( allow4handler ) { /* * if we were waiting for sense data we copy the sense * bytes only as the original status information was * saved prior to sense already. */ if ( ioinfo[irq]->ui.flags.w4sense ) { int sense_count = SENSE_MAX_COUNT-ioinfo[irq]->devstat.rescnt; #ifdef CONFIG_DEBUG_IO if ( irq != cons_dev ) printk( "s390_process_IRQ( %04X ) : " "BASIC SENSE bytes avail %d\n", irq, sense_count ); #endif ioinfo[irq]->ui.flags.w4sense = 0; ((devstat_t *)(action->dev_id))->flag |= DEVSTAT_FLAG_SENSE_AVAIL; ((devstat_t *)(action->dev_id))->scnt = sense_count; if ( sense_count >= 0 ) { memcpy( ((devstat_t *)(action->dev_id))->ii.sense.data, &(ioinfo[irq]->sense_data), sense_count); } else { #if 1 panic( "s390_process_IRQ(%04x) encountered " "negative sense count\n", irq); #else printk( KERN_CRIT"s390_process_IRQ(%04x) encountered " "negative sense count\n", irq); #endif } /* endif */ } else { memcpy( action->dev_id, dp, sdevstat ); } /* endif */ } /* endif */ /* * for status pending situations other than deferred interrupt * conditions detected by s390_process_IRQ() itself we must not * call the handler. This will synchronously be reported back * to the caller instead, e.g. when detected during do_IO(). */ if ( ioinfo[irq]->ui.flags.s_pend || ioinfo[irq]->ui.flags.unready || ioinfo[irq]->ui.flags.repnone ) { if ( ending_status ) { ioinfo[irq]->ui.flags.busy = 0; ioinfo[irq]->ui.flags.doio = 0; ioinfo[irq]->ui.flags.haltio = 0; ioinfo[irq]->ui.flags.fast = 0; ioinfo[irq]->ui.flags.repall = 0; ioinfo[irq]->ui.flags.w4final = 0; dp->flag |= DEVSTAT_FINAL_STATUS; action->dev_id->flag |= DEVSTAT_FINAL_STATUS; } /* endif */ allow4handler = 0; } /* endif */ /* * Call device action handler if applicable */ if ( allow4handler ) { /* * We only reset the busy condition when we are sure that no further * interrupt is pending for the current I/O request (ending_status). */ if ( ending_status || !ioinfo[irq]->ui.flags.oper ) { ioinfo[irq]->ui.flags.oper = 1; /* dev IS oper */ ioinfo[irq]->ui.flags.busy = 0; ioinfo[irq]->ui.flags.doio = 0; ioinfo[irq]->ui.flags.haltio = 0; ioinfo[irq]->ui.flags.fast = 0; ioinfo[irq]->ui.flags.repall = 0; ioinfo[irq]->ui.flags.w4final = 0; dp->flag |= DEVSTAT_FINAL_STATUS; action->dev_id->flag |= DEVSTAT_FINAL_STATUS; action->handler( irq, action->dev_id, ®s ); // // reset intparm after final status or we will badly present unsolicited // interrupts with a intparm value possibly no longer valid. // dp->intparm = 0; // // Was there anything queued ? Start the pending channel program // if there is one. // if ( ioinfo[irq]->ui.flags.doio_q ) { int ret; ret = s390_start_IO( irq, ioinfo[irq]->qcpa, ioinfo[irq]->qintparm, ioinfo[irq]->qlpm, ioinfo[irq]->qflag); ioinfo[irq]->ui.flags.doio_q = 0; /* * If s390_start_IO() failed call the device's interrupt * handler, the IRQ related devstat area was setup by * s390_start_IO() accordingly already (status pending * condition). */ if ( ret ) { action->handler( irq, action->dev_id, ®s ); } /* endif */ } /* endif */ } else { ioinfo[irq]->ui.flags.w4final = 1; /* * Eventually reset subchannel PCI status and * set the PCI or SUSPENDED flag in the user * device status block if appropriate. */ if ( dp->cstat & SCHN_STAT_PCI ) { action->dev_id->flag |= DEVSTAT_PCI; dp->cstat &= ~SCHN_STAT_PCI; } if ( actl & SCSW_ACTL_SUSPENDED ) { action->dev_id->flag |= DEVSTAT_SUSPENDED; } /* endif */ action->handler( irq, action->dev_id, ®s ); } /* endif */ } /* endif */ break; case 3: /* device/path not operational */ ioinfo[irq]->ui.flags.busy = 0; ioinfo[irq]->ui.flags.doio = 0; ioinfo[irq]->ui.flags.haltio = 0; dp->cstat = 0; dp->dstat = 0; if ( ioinfo[irq]->ulpm != ioinfo[irq]->opm ) { /* * either it was the only path or it was restricted ... */ ioinfo[irq]->opm &= ~(ioinfo[irq]->devstat.ii.irb.esw.esw1.lpum); } else { ioinfo[irq]->opm = 0; } /* endif */ if ( ioinfo[irq]->opm == 0 ) { ioinfo[irq]->ui.flags.oper = 0; } /* endif */ ioinfo[irq]->devstat.flag |= DEVSTAT_NOT_OPER; ioinfo[irq]->devstat.flag |= DEVSTAT_FINAL_STATUS; /* * When we find a device "not oper" we save the status * information into the device status area and call the * device specific interrupt handler. * * Note: currently we don't have any way to reenable * the device unless an unsolicited interrupt * is presented. We don't check for spurious * interrupts on "not oper" conditions. */ if ( ( ioinfo[irq]->ui.flags.fast ) && ( ioinfo[irq]->ui.flags.w4final ) ) { /* * If a new request was queued already, we have * to simulate the "not oper" status for the * queued request by switching the "intparm" value * and notify the interrupt handler. */ if ( ioinfo[irq]->ui.flags.doio_q ) { ioinfo[irq]->devstat.intparm = ioinfo[irq]->qintparm; } /* endif */ } /* endif */ ioinfo[irq]->ui.flags.fast = 0; ioinfo[irq]->ui.flags.repall = 0; ioinfo[irq]->ui.flags.w4final = 0; /* * take fast exit if no handler is available */ if ( !action ) return( ending_status ); memcpy( action->dev_id, &(ioinfo[irq]->devstat), sdevstat ); ioinfo[irq]->devstat.intparm = 0; if ( !ioinfo[irq]->ui.flags.s_pend ) { action->handler( irq, action->dev_id, ®s ); } /* endif */ ending_status = 1; break; } /* endswitch */ return( ending_status ); } /* * Set the special i/o-interruption sublass 7 for the * device specified by parameter irq. There can only * be a single device been operated on this special * isc. This function is aimed being able to check * on special device interrupts in disabled state, * without having to delay I/O processing (by queueing) * for non-console devices. * * Setting of this isc is done by set_cons_dev(), while * reset_cons_dev() resets this isc and re-enables the * default isc3 for this device. wait_cons_dev() allows * to actively wait on an interrupt for this device in * disabed state. When the interrupt condition is * encountered, wait_cons_dev(9 calls do_IRQ() to have * the console device driver processing the interrupt. */ int set_cons_dev( int irq ) { int ccode; unsigned long cr6 __attribute__ ((aligned (8))); int rc = 0; if ( cons_dev != -1 ) { rc = -EBUSY; } else if ( (irq > highest_subchannel) || (irq < 0) ) { rc = -ENODEV; } else if ( ioinfo[irq] == INVALID_STORAGE_AREA ) { return( -ENODEV); } else { /* * modify the indicated console device to operate * on special console interrupt sublass 7 */ ccode = stsch( irq, &(ioinfo[irq]->schib) ); if (ccode) { rc = -ENODEV; ioinfo[irq]->devstat.flag |= DEVSTAT_NOT_OPER; } else { ioinfo[irq]->schib.pmcw.isc = 7; ccode = msch( irq, &(ioinfo[irq]->schib) ); if (ccode) { rc = -EIO; } else { cons_dev = irq; /* * enable console I/O-interrupt sublass 7 */ __ctl_store( cr6, 6, 6); cr6 |= 0x01000000; __ctl_load( cr6, 6, 6); } /* endif */ } /* endif */ } /* endif */ return( rc); } int reset_cons_dev( int irq) { int rc = 0; int ccode; long cr6 __attribute__ ((aligned (8))); if ( cons_dev != -1 ) { rc = -EBUSY; } else if ( (irq > highest_subchannel) || (irq < 0) ) { rc = -ENODEV; } else if ( ioinfo[irq] == INVALID_STORAGE_AREA ) { return( -ENODEV); } else { /* * reset the indicated console device to operate * on default console interrupt sublass 3 */ ccode = stsch( irq, &(ioinfo[irq]->schib) ); if (ccode) { rc = -ENODEV; ioinfo[irq]->devstat.flag |= DEVSTAT_NOT_OPER; } else { ioinfo[irq]->schib.pmcw.isc = 3; ccode = msch( irq, &(ioinfo[irq]->schib) ); if (ccode) { rc = -EIO; } else { cons_dev = -1; /* * disable special console I/O-interrupt sublass 7 */ __ctl_store( cr6, 6, 6); cr6 &= 0xFEFFFFFF; __ctl_load( cr6, 6, 6); } /* endif */ } /* endif */ } /* endif */ return( rc); } int wait_cons_dev( int irq ) { int rc = 0; long save_cr6; if ( irq == cons_dev ) { /* * before entering the spinlock we may already have * processed the interrupt on a different CPU ... */ if ( ioinfo[irq]->ui.flags.busy == 1 ) { long cr6 __attribute__ ((aligned (8))); /* * disable all, but isc 7 (console device) */ __ctl_store( cr6, 6, 6); save_cr6 = cr6; cr6 &= 0x01FFFFFF; __ctl_load( cr6, 6, 6); do { tpi_info_t tpi_info = {0,}; if (tpi(&tpi_info) == 1) { s390_process_IRQ( tpi_info.irq ); } else { s390irq_spin_unlock(irq); udelay(100); s390irq_spin_lock(irq); } eieio(); } while (ioinfo[irq]->ui.flags.busy == 1); /* * restore previous isc value */ cr6 = save_cr6; __ctl_load( cr6, 6, 6); } /* endif */ } else { rc = EINVAL; } /* endif */ return(rc); } int enable_cpu_sync_isc( int irq ) { int ccode; long cr6 __attribute__ ((aligned (8))); int count = 0; int rc = 0; /* This one spins until it can get the sync_isc lock for irq# irq */ if ( irq <= highest_subchannel && ioinfo[irq] != INVALID_STORAGE_AREA ) { if ( atomic_read( &sync_isc ) != irq ) atomic_compare_and_swap_spin( -1, irq, &sync_isc ); ioinfo[irq]->syncnt++; if ( ioinfo[irq]->syncnt > 255 ) /* fixme : magic number */ { panic("Too many recursive calls to enable_sync_isc"); } /* * we only run the STSCH/MSCH path for the first enablement */ else if ( ioinfo[irq]->syncnt == 1) { ioinfo[irq]->ui.flags.syncio = 1; ccode = stsch( irq, &(ioinfo[irq]->schib) ); if ( !ccode ) { ioinfo[irq]->schib.pmcw.isc = 5; do { ccode = msch( irq, &(ioinfo[irq]->schib) ); if (ccode == 0 ) { /* * enable special isc */ __ctl_store( cr6, 6, 6); cr6 |= 0x04000000; // enable sync isc 5 cr6 &= 0xEFFFFFFF; // disable standard isc 3 __ctl_load( cr6, 6, 6); } else if (ccode == 3) { rc = -ENODEV; // very unlikely } else if (ccode == 2) { rc = -EBUSY; // device busy ... } else if (ccode == 1) { // // process pending status // ioinfo[irq]->ui.flags.s_pend = 1; s390_process_IRQ( irq ); ioinfo[irq]->ui.flags.s_pend = 0; count++; } /* endif */ } while ( ccode == 1 && count < 3 ); if ( count == 3) { rc = -EIO; } /* endif */ } else { rc = -ENODEV; // device is not-operational } /* endif */ } /* endif */ } else { rc = -EINVAL; } /* endif */ return( rc); } int disable_cpu_sync_isc( int irq) { int rc = 0; int retry1 = 5; int retry2 = 5; int clear_pend = 0; int ccode; long cr6 __attribute__ ((aligned (8))); if ( irq <= highest_subchannel && ioinfo[irq] != INVALID_STORAGE_AREA ) { /* * We disable if we're the top user only, as we may * run recursively ... * We must not decrease the count immediately; during * msch() processing we may face another pending * status we have to process recursively (sync). */ if ( (ioinfo[irq]->syncnt-1) == 0 ) { ccode = stsch( irq, &(ioinfo[irq]->schib) ); ioinfo[irq]->schib.pmcw.isc = 3; do { do { ccode = msch( irq, &(ioinfo[irq]->schib) ); switch ( ccode ) { case 0: /* * disable special interrupt subclass in CPU */ __ctl_store( cr6, 6, 6); cr6 &= 0xFBFFFFFF; // disable sync isc 5 cr6 |= 0x10000000; // enable standard isc 3 __ctl_load( cr6, 6, 6); break; case 1: ioinfo[irq]->ui.flags.s_pend = 1; s390_process_IRQ( irq ); ioinfo[irq]->ui.flags.s_pend = 0; retry2--; break; case 2: break; default: retry2 = 0; break; } /* endswitch */ } while ( retry2 && (ccode != 0) ); retry1--; /* try stopping it ... */ if ( (ccode) && !clear_pend ) { clear_IO( irq, 0x00004711, 0 ); clear_pend = 1; } /* endif */ udelay( 100); } while ( retry1 && ccode ); ioinfo[irq]->syncnt = 0; ioinfo[irq]->ui.flags.syncio = 0; atomic_set( &sync_isc, -1); } else { ioinfo[irq]->syncnt--; } /* endif */ } else { rc = -EINVAL; } /* endif */ return( rc); } // // Input : // devno - device number // ps - pointer to sense ID data area // // Output : none // void VM_virtual_device_info( __u16 devno, senseid_t *ps ) { diag210_t *p_diag_data; int ccode; int error = 0; if ( init_IRQ_complete ) { p_diag_data = kmalloc( sizeof( diag210_t), GFP_DMA ); } else { p_diag_data = alloc_bootmem_low( sizeof( diag210_t)); } /* endif */ p_diag_data->vrdcdvno = devno; p_diag_data->vrdclen = sizeof( diag210_t); ccode = diag210( (diag210_t *)virt_to_phys( p_diag_data ) ); ps->reserved = 0xff; switch (p_diag_data->vrdcvcla) { case 0x80: switch (p_diag_data->vrdcvtyp) { case 00: ps->cu_type = 0x3215; break; default: error = 1; break; } /* endswitch */ break; case 0x40: switch (p_diag_data->vrdcvtyp) { case 0xC0: ps->cu_type = 0x5080; break; case 0x80: ps->cu_type = 0x2250; break; case 0x04: ps->cu_type = 0x3277; break; case 0x01: ps->cu_type = 0x3278; break; default: error = 1; break; } /* endswitch */ break; case 0x20: switch (p_diag_data->vrdcvtyp) { case 0x84: ps->cu_type = 0x3505; break; case 0x82: ps->cu_type = 0x2540; break; case 0x81: ps->cu_type = 0x2501; break; default: error = 1; break; } /* endswitch */ break; case 0x10: switch (p_diag_data->vrdcvtyp) { case 0x84: ps->cu_type = 0x3525; break; case 0x82: ps->cu_type = 0x2540; break; case 0x4F: case 0x4E: case 0x48: ps->cu_type = 0x3820; break; case 0x4D: case 0x49: case 0x45: ps->cu_type = 0x3800; break; case 0x4B: ps->cu_type = 0x4248; break; case 0x4A: ps->cu_type = 0x4245; break; case 0x47: ps->cu_type = 0x3262; break; case 0x43: ps->cu_type = 0x3203; break; case 0x42: ps->cu_type = 0x3211; break; case 0x41: ps->cu_type = 0x1403; break; default: error = 1; break; } /* endswitch */ break; case 0x08: switch (p_diag_data->vrdcvtyp) { case 0x82: ps->cu_type = 0x3422; break; case 0x81: ps->cu_type = 0x3490; break; case 0x10: ps->cu_type = 0x3420; break; case 0x02: ps->cu_type = 0x3430; break; case 0x01: ps->cu_type = 0x3480; break; case 0x42: ps->cu_type = 0x3424; break; case 0x44: ps->cu_type = 0x9348; break; default: error = 1; break; } /* endswitch */ break; case 02: /* special device class ... */ switch (p_diag_data->vrdcvtyp) { case 0x20: /* OSA */ ps->cu_type = 0x3088; ps->cu_model = 0x60; break; default: error = 1; break; } /* endswitch */ break; default: error = 1; break; } /* endswitch */ if ( init_IRQ_complete ) { kfree( p_diag_data ); } else { free_bootmem( (unsigned long)p_diag_data, sizeof( diag210_t) ); } /* endif */ if ( error ) { printk( "DIAG X'210' for " "device %04X returned " "(cc = %d): vdev class : %02X, " "vdev type : %04X \n ... rdev class : %02X, rdev type : %04X, rdev model: %02X\n", devno, ccode, p_diag_data->vrdcvcla, p_diag_data->vrdcvtyp, p_diag_data->vrdcrccl, p_diag_data->vrdccrty, p_diag_data->vrdccrmd ); } /* endif */ } /* * This routine returns the characteristics for the device * specified. Some old devices might not provide the necessary * command code information during SenseID processing. In this * case the function returns -EINVAL. Otherwise the function * allocates a decice specific data buffer and provides the * device characteristics together with the buffer size. Its * the callers responability to release the kernel memory if * not longer needed. In case of persistent I/O problems -EBUSY * is returned. * * The function may be called enabled or disabled. However, the * caller must have locked the irq it is requesting data for. * * Note : It would have been nice to collect this information * during init_IRQ() processing but this is not possible * * a) without statically pre-allocation fixed size buffers * as virtual memory management isn't available yet. * * b) without unnecessarily increase system startup by * evaluating devices eventually not used at all. */ int read_dev_chars( int irq, void **buffer, int length ) { unsigned int flags; ccw1_t *rdc_ccw; devstat_t devstat; char *rdc_buf; int devflag; int ret = 0; int emulated = 0; int retry = 5; if ( !buffer || !length ) { return( -EINVAL ); } /* endif */ if ( (irq > highest_subchannel) || (irq < 0 ) ) { return( -ENODEV ); } else if ( ioinfo[irq] == INVALID_STORAGE_AREA ) { return( -ENODEV); } if ( ioinfo[irq]->ui.flags.oper == 0 ) { return( -ENODEV ); } /* endif */ /* * Before playing around with irq locks we should assure * running disabled on (just) our CPU. Sync. I/O requests * also require to run disabled. * * Note : as no global lock is required, we must not use * cli(), but __cli() instead. */ __save_flags(flags); __cli(); rdc_ccw = &ioinfo[irq]->senseccw; if ( !ioinfo[irq]->ui.flags.ready ) { ret = request_irq( irq, init_IRQ_handler, 0, "RDC", &devstat ); if ( !ret ) { emulated = 1; } /* endif */ } /* endif */ if ( !ret ) { if ( ! *buffer ) { rdc_buf = kmalloc( length, GFP_KERNEL); } else { rdc_buf = *buffer; } /* endif */ if ( !rdc_buf ) { ret = -ENOMEM; } else { do { rdc_ccw->cmd_code = CCW_CMD_RDC; rdc_ccw->count = length; rdc_ccw->flags = CCW_FLAG_SLI; set_normalized_cda( rdc_ccw, (unsigned long)rdc_buf ); memset( (devstat_t *)(ioinfo[irq]->irq_desc.action->dev_id), '\0', sizeof( devstat_t)); ret = s390_start_IO( irq, rdc_ccw, 0x00524443, // RDC 0, // n/a DOIO_WAIT_FOR_INTERRUPT | DOIO_DONT_CALL_INTHDLR ); retry--; devflag = ((devstat_t *)(ioinfo[irq]->irq_desc.action->dev_id))->flag; clear_normalized_cda( rdc_ccw); } while ( ( retry ) && ( ret || (devflag & DEVSTAT_STATUS_PENDING) ) ); } /* endif */ if ( !retry ) { ret = -EBUSY; } /* endif */ __restore_flags(flags); /* * on success we update the user input parms */ if ( !ret ) { *buffer = rdc_buf; } /* endif */ if ( emulated ) { free_irq( irq, &devstat); } /* endif */ } /* endif */ return( ret ); } /* * Read Configuration data */ int read_conf_data( int irq, void **buffer, int *length, __u8 lpm ) { unsigned long flags; int ciw_cnt; int found = 0; // RCD CIW found int ret = 0; // return code if ( (irq > highest_subchannel) || (irq < 0 ) ) { return( -ENODEV ); } else if ( ioinfo[irq] == INVALID_STORAGE_AREA ) { return( -ENODEV); } else if ( !buffer || !length ) { return( -EINVAL); } else if ( ioinfo[irq]->ui.flags.oper == 0 ) { return( -ENODEV ); } else if ( ioinfo[irq]->ui.flags.esid == 0 ) { return( -EOPNOTSUPP ); } /* endif */ /* * scan for RCD command in extended SenseID data */ for ( ciw_cnt = 0; (found == 0) && (ciw_cnt < 62); ciw_cnt++ ) { if ( ioinfo[irq]->senseid.ciw[ciw_cnt].ct == CIW_TYPE_RCD ) { /* * paranoia check ... */ if ( ioinfo[irq]->senseid.ciw[ciw_cnt].cmd != 0 ) { found = 1; } /* endif */ break; } /* endif */ } /* endfor */ if ( found ) { devstat_t devstat; /* inline device status area */ devstat_t *pdevstat; int ioflags; ccw1_t *rcd_ccw = &ioinfo[irq]->senseccw; char *rcd_buf = NULL; int emulated = 0; /* no i/O handler installed */ int retry = 5; /* retry count */ __save_flags(flags); __cli(); if ( !ioinfo[irq]->ui.flags.ready ) { pdevstat = &devstat; ret = request_irq( irq, init_IRQ_handler, 0, "RCD", pdevstat ); if ( !ret ) { emulated = 1; } /* endif */ } else { pdevstat = ioinfo[irq]->irq_desc.action->dev_id; } /* endif */ if ( !ret ) { if ( init_IRQ_complete ) { rcd_buf = kmalloc( ioinfo[irq]->senseid.ciw[ciw_cnt].count, GFP_DMA); } else { rcd_buf = alloc_bootmem_low( ioinfo[irq]->senseid.ciw[ciw_cnt].count); } /* endif */ if ( rcd_buf == NULL ) { ret = -ENOMEM; } /* endif */ if ( !ret ) { memset( rcd_buf, '\0', ioinfo[irq]->senseid.ciw[ciw_cnt].count); do { rcd_ccw->cmd_code = ioinfo[irq]->senseid.ciw[ciw_cnt].cmd; rcd_ccw->cda = (__u32)virt_to_phys( rcd_buf ); rcd_ccw->count = ioinfo[irq]->senseid.ciw[ciw_cnt].count; rcd_ccw->flags = CCW_FLAG_SLI; memset( pdevstat, '\0', sizeof( devstat_t)); if ( lpm ) { ioflags = DOIO_WAIT_FOR_INTERRUPT | DOIO_VALID_LPM | DOIO_DONT_CALL_INTHDLR; } else { ioflags = DOIO_WAIT_FOR_INTERRUPT | DOIO_DONT_CALL_INTHDLR; } /* endif */ ret = s390_start_IO( irq, rcd_ccw, 0x00524344, // == RCD lpm, ioflags ); switch ( ret ) { case 0 : case -EIO : if ( !(pdevstat->flag & ( DEVSTAT_STATUS_PENDING | DEVSTAT_NOT_OPER | DEVSTAT_FLAG_SENSE_AVAIL ) ) ) { retry = 0; // we got it ... } else { retry--; // try again ... } /* endif */ break; default : // -EBUSY, -ENODEV, ??? retry = 0; } /* endswitch */ } while ( retry ); } /* endif */ __restore_flags( flags ); } /* endif */ /* * on success we update the user input parms */ if ( ret == 0 ) { *length = ioinfo[irq]->senseid.ciw[ciw_cnt].count; *buffer = rcd_buf; } else { if ( rcd_buf != NULL ) { if ( init_IRQ_complete ) { kfree( rcd_buf ); } else { free_bootmem( (unsigned long)rcd_buf, ioinfo[irq]->senseid.ciw[ciw_cnt].count); } /* endif */ } /* endif */ *buffer = NULL; *length = 0; } /* endif */ if ( emulated ) free_irq( irq, pdevstat); } else { ret = -EOPNOTSUPP; } /* endif */ return( ret ); } int get_dev_info( int irq, s390_dev_info_t * pdi) { return( get_dev_info_by_irq( irq, pdi)); } static int __inline__ get_next_available_irq( ioinfo_t *pi) { int ret_val; while ( TRUE ) { if ( pi->ui.flags.oper ) { ret_val = pi->irq; break; } else { pi = pi->next; // // leave at end of list unconditionally // if ( pi == NULL ) { ret_val = -ENODEV; break; } } /* endif */ } /* endwhile */ return ret_val; } int get_irq_first( void ) { int ret_irq; if ( ioinfo_head ) { if ( ioinfo_head->ui.flags.oper ) { ret_irq = ioinfo_head->irq; } else if ( ioinfo_head->next ) { ret_irq = get_next_available_irq( ioinfo_head->next ); } else { ret_irq = -ENODEV; } /* endif */ } else { ret_irq = -ENODEV; } /* endif */ return ret_irq; } int get_irq_next( int irq ) { int ret_irq; if ( ioinfo[irq] != INVALID_STORAGE_AREA ) { if ( ioinfo[irq]->next ) { if ( ioinfo[irq]->next->ui.flags.oper ) { ret_irq = ioinfo[irq]->next->irq; } else { ret_irq = get_next_available_irq( ioinfo[irq]->next ); } /* endif */ } else { ret_irq = -ENODEV; } /* endif */ } else { ret_irq = -EINVAL; } /* endif */ return ret_irq; } int get_dev_info_by_irq( int irq, s390_dev_info_t *pdi) { if ( irq > highest_subchannel || irq < 0 ) { return -ENODEV; } else if ( pdi == NULL ) { return -EINVAL; } else if ( ioinfo[irq] == INVALID_STORAGE_AREA ) { return( -ENODEV); } else { pdi->devno = ioinfo[irq]->schib.pmcw.dev; pdi->irq = irq; if ( ioinfo[irq]->ui.flags.oper && !ioinfo[irq]->ui.flags.unknown ) { pdi->status = 0; memcpy( &(pdi->sid_data), &ioinfo[irq]->senseid, sizeof( senseid_t)); } else if ( ioinfo[irq]->ui.flags.unknown ) { pdi->status = DEVSTAT_UNKNOWN_DEV; memset( &(pdi->sid_data), '\0', sizeof( senseid_t)); pdi->sid_data.cu_type = 0xFFFF; } else { pdi->status = DEVSTAT_NOT_OPER; memset( &(pdi->sid_data), '\0', sizeof( senseid_t)); pdi->sid_data.cu_type = 0xFFFF; } /* endif */ if ( ioinfo[irq]->ui.flags.ready ) pdi->status |= DEVSTAT_DEVICE_OWNED; } /* endif */ return 0; } int get_dev_info_by_devno( __u16 devno, s390_dev_info_t *pdi) { int i; int rc = -ENODEV; if ( devno > 0x0000ffff ) { return -ENODEV; } else if ( pdi == NULL ) { return -EINVAL; } else { for ( i=0; i <= highest_subchannel; i++ ) { if ( ioinfo[i] != INVALID_STORAGE_AREA && ioinfo[i]->schib.pmcw.dev == devno ) { pdi->irq = i; pdi->devno = devno; if ( ioinfo[i]->ui.flags.oper && !ioinfo[i]->ui.flags.unknown ) { pdi->status = 0; memcpy( &(pdi->sid_data), &ioinfo[i]->senseid, sizeof( senseid_t)); } else if ( ioinfo[i]->ui.flags.unknown ) { pdi->status = DEVSTAT_UNKNOWN_DEV; memset( &(pdi->sid_data), '\0', sizeof( senseid_t)); pdi->sid_data.cu_type = 0xFFFF; } else { pdi->status = DEVSTAT_NOT_OPER; memset( &(pdi->sid_data), '\0', sizeof( senseid_t)); pdi->sid_data.cu_type = 0xFFFF; } /* endif */ if ( ioinfo[i]->ui.flags.ready ) pdi->status |= DEVSTAT_DEVICE_OWNED; rc = 0; /* found */ break; } /* endif */ } /* endfor */ return( rc); } /* endif */ } int get_irq_by_devno( __u16 devno ) { int i; int rc = -1; if ( devno <= 0x0000ffff ) { for ( i=0; i <= highest_subchannel; i++ ) { if ( (ioinfo[i] != INVALID_STORAGE_AREA ) && (ioinfo[i]->schib.pmcw.dev == devno) && (ioinfo[i]->schib.pmcw.dnv == 1 ) ) { rc = i; break; } /* endif */ } /* endfor */ } /* endif */ return( rc); } unsigned int get_devno_by_irq( int irq ) { if ( ( irq > highest_subchannel ) || ( irq < 0 ) || ( ioinfo[irq] == INVALID_STORAGE_AREA ) ) { return -1; } /* endif */ /* * we don't need to check for the device be operational * as the initial STSCH will always present the device * number defined by the IOCDS regardless of the device * existing or not. However, there could be subchannels * defined who's device number isn't valid ... */ if ( ioinfo[irq]->schib.pmcw.dnv ) return( ioinfo[irq]->schib.pmcw.dev ); else return -1; } /* * s390_device_recognition_irq * * Used for individual device recognition. Issues the device * independant SenseID command to obtain info the device type. * */ void s390_device_recognition_irq( int irq ) { int ret; unsigned long psw_flags; /* * We issue the SenseID command on I/O subchannels we think are * operational only. */ if ( ( ioinfo[irq] != INVALID_STORAGE_AREA ) && ( ioinfo[irq]->schib.pmcw.st == 0 ) && ( ioinfo[irq]->ui.flags.oper == 1 ) ) { int irq_ret; devstat_t devstat; irq_ret = request_irq( irq, init_IRQ_handler, 0, "INIT", &devstat); if ( !irq_ret ) { ret = enable_cpu_sync_isc( irq ); if ( ret ) { free_irq( irq, &devstat ); return; // fixme ! fast exit ... grr } else { ioinfo[irq]->ui.flags.unknown = 0; memset( &ioinfo[irq]->senseid, '\0', sizeof( senseid_t)); s390_SenseID( irq, &ioinfo[irq]->senseid, 0xff ); #if 0 /* FIXME */ /* * We initially check the configuration data for * those devices with more than a single path */ if ( ioinfo[irq]->schib.pmcw.pim != 0x80 ) { char *prcd; int lrcd; ret = read_conf_data( irq, (void **)&prcd, &lrcd, 0 ); if ( !ret ) // on success only ... { #ifdef CONFIG_DEBUG_IO char buffer[80]; sprintf( buffer, "RCD for device(%04X)/" "subchannel(%04X) returns :\n", ioinfo[irq]->schib.pmcw.dev, irq ); s390_displayhex( buffer, prcd, lrcd ); #endif if ( init_IRQ_complete ) { kfree( prcd ); } else { free_bootmem( (unsigned long)prcd, lrcd ); } /* endif */ } /* endif */ } /* endif */ #endif s390_DevicePathVerification( irq, 0 ); disable_cpu_sync_isc( irq ); } /* endif */ free_irq( irq, &devstat ); } /* endif */ } /* endif */ } /* * s390_device_recognition_all * * Used for system wide device recognition. * */ void s390_device_recognition_all( void) { int irq = 0; /* let's start with subchannel 0 ... */ do { s390_device_recognition_irq( irq ); irq ++; } while ( irq <= highest_subchannel ); } /* * s390_search_devices * * Determines all subchannels available to the system. * */ void s390_process_subchannels( void) { int ret; int irq = 0; /* Evaluate all subchannels starting with 0 ... */ do { ret = s390_validate_subchannel( irq, 0); if ( ret != -ENXIO) irq++; } while ( (ret != -ENXIO) && (irq < __MAX_SUBCHANNELS) ); highest_subchannel = (--irq); printk( "Highest subchannel number detected (hex) : %04X\n", highest_subchannel); } /* * s390_validate_subchannel() * * Process the subchannel for the requested irq. Returns 1 for valid * subchannels, otherwise 0. */ int s390_validate_subchannel( int irq, int enable ) { int retry; /* retry count for status pending conditions */ int ccode; /* condition code for stsch() only */ int ccode2; /* condition code for other I/O routines */ schib_t *p_schib; int ret; /* * The first subchannel that is not-operational (ccode==3) * indicates that there aren't any more devices available. */ if ( ( init_IRQ_complete ) && ( ioinfo[irq] != INVALID_STORAGE_AREA ) ) { p_schib = &ioinfo[irq]->schib; } else { p_schib = p_init_schib; } /* endif */ /* * If we knew the device before we assume the worst case ... */ if ( ioinfo[irq] != INVALID_STORAGE_AREA ) { ioinfo[irq]->ui.flags.oper = 0; ioinfo[irq]->ui.flags.dval = 0; } /* endif */ ccode = stsch( irq, p_schib); if ( !ccode ) { /* * ... just being curious we check for non I/O subchannels */ if ( p_schib->pmcw.st ) { printk( "Subchannel %04X reports " "non-I/O subchannel type %04X\n", irq, p_schib->pmcw.st); if ( ioinfo[irq] != INVALID_STORAGE_AREA ) ioinfo[irq]->ui.flags.oper = 0; } /* endif */ if ( p_schib->pmcw.dnv ) { if ( ioinfo[irq] == INVALID_STORAGE_AREA ) { if ( !init_IRQ_complete ) { ioinfo[irq] = (ioinfo_t *)alloc_bootmem_low( sizeof(ioinfo_t)); } else { ioinfo[irq] = (ioinfo_t *)kmalloc( sizeof(ioinfo_t), GFP_DMA ); } /* endif */ memset( ioinfo[irq], '\0', sizeof( ioinfo_t)); memcpy( &ioinfo[irq]->schib, p_init_schib, sizeof( schib_t)); ioinfo[irq]->irq_desc.status = IRQ_DISABLED; ioinfo[irq]->irq_desc.handler = &no_irq_type; /* * We have to insert the new ioinfo element * into the linked list, either at its head, * its tail or insert it. */ if ( ioinfo_head == NULL ) /* first element */ { ioinfo_head = ioinfo[irq]; ioinfo_tail = ioinfo[irq]; } else if ( irq < ioinfo_head->irq ) /* new head */ { ioinfo[irq]->next = ioinfo_head; ioinfo_head->prev = ioinfo[irq]; ioinfo_head = ioinfo[irq]; } else if ( irq > ioinfo_tail->irq ) /* new tail */ { ioinfo_tail->next = ioinfo[irq]; ioinfo[irq]->prev = ioinfo_tail; ioinfo_tail = ioinfo[irq]; } else /* insert element */ { ioinfo_t *pi = ioinfo_head; do { if ( irq < pi->next->irq ) { ioinfo[irq]->next = pi->next; ioinfo[irq]->prev = pi; pi->next->prev = ioinfo[irq]; pi->next = ioinfo[irq]; break; } /* endif */ pi = pi->next; } while ( 1 ); } /* endif */ } /* endif */ // initialize some values ... ioinfo[irq]->ui.flags.pgid_supp = 1; ioinfo[irq]->opm = ioinfo[irq]->schib.pmcw.pim & ioinfo[irq]->schib.pmcw.pam & ioinfo[irq]->schib.pmcw.pom; if ( cio_show_msg ) { printk( KERN_INFO"Detected device %04X " "on subchannel %04X" " - PIM = %02X, PAM = %02X, POM = %02X\n", ioinfo[irq]->schib.pmcw.dev, irq, ioinfo[irq]->schib.pmcw.pim, ioinfo[irq]->schib.pmcw.pam, ioinfo[irq]->schib.pmcw.pom); } /* endif */ /* * initialize ioinfo structure */ ioinfo[irq]->irq = irq; if(!ioinfo[irq]->ui.flags.ready) { ioinfo[irq]->nopfunc = NULL; ioinfo[irq]->ui.flags.busy = 0; ioinfo[irq]->ui.flags.dval = 1; ioinfo[irq]->devstat.intparm = 0; } ioinfo[irq]->devstat.devno = ioinfo[irq]->schib.pmcw.dev; ioinfo[irq]->devno = ioinfo[irq]->schib.pmcw.dev; /* * We should have at least one CHPID ... */ if ( ioinfo[irq]->opm ) { /* * We now have to initially ... * ... set "interruption sublass" * ... enable "concurrent sense" * ... enable "multipath mode" if more than one * CHPID is available. This is done regardless * whether multiple paths are available for us. * * Note : we don't enable the device here, this is temporarily * done during device sensing below. */ ioinfo[irq]->schib.pmcw.isc = 3; /* could be smth. else */ ioinfo[irq]->schib.pmcw.csense = 1; /* concurrent sense */ ioinfo[irq]->schib.pmcw.ena = enable; ioinfo[irq]->schib.pmcw.intparm = ioinfo[irq]->schib.pmcw.dev; if ( ( ioinfo[irq]->opm != 0x80 ) && ( ioinfo[irq]->opm != 0x40 ) && ( ioinfo[irq]->opm != 0x20 ) && ( ioinfo[irq]->opm != 0x10 ) && ( ioinfo[irq]->opm != 0x08 ) && ( ioinfo[irq]->opm != 0x04 ) && ( ioinfo[irq]->opm != 0x02 ) && ( ioinfo[irq]->opm != 0x01 ) ) { ioinfo[irq]->schib.pmcw.mp = 1; /* multipath mode */ } /* endif */ retry = 5; do { ccode2 = msch_err( irq, &ioinfo[irq]->schib); switch (ccode2) { case 0: // successful completion // // concurrent sense facility available ... // ioinfo[irq]->ui.flags.oper = 1; ioinfo[irq]->ui.flags.consns = 1; ret = 0; break; case 1: // status pending // // How can we have a pending status as // device is disabled for interrupts ? // Anyway, process it ... // ioinfo[irq]->ui.flags.s_pend = 1; s390_process_IRQ( irq); ioinfo[irq]->ui.flags.s_pend = 0; retry--; ret = -EIO; break; case 2: // busy /* * we mark it not-oper as we can't * properly operate it ! */ ioinfo[irq]->ui.flags.oper = 0; udelay( 100); /* allow for recovery */ retry--; ret = -EBUSY; break; case 3: // not operational ioinfo[irq]->ui.flags.oper = 0; retry = 0; ret = -ENODEV; break; default: #define PGMCHK_OPERAND_EXC 0x15 if ( (ccode2 & PGMCHK_OPERAND_EXC) == PGMCHK_OPERAND_EXC ) { /* * re-issue the modify subchannel without trying to * enable the concurrent sense facility */ ioinfo[irq]->schib.pmcw.csense = 0; ccode2 = msch_err( irq, &ioinfo[irq]->schib); if ( ccode2 != 0 ) { printk( " ... msch() (2) failed with CC = %X\n", ccode2 ); ioinfo[irq]->ui.flags.oper = 0; ret = -EIO; } else { ioinfo[irq]->ui.flags.oper = 1; ioinfo[irq]->ui.flags.consns = 0; ret = 0; } /* endif */ } else { printk( " ... msch() (1) failed with CC = %X\n", ccode2); ioinfo[irq]->ui.flags.oper = 0; ret = -EIO; } /* endif */ retry = 0; break; } /* endswitch */ } while ( ccode2 && retry ); if ( (ccode2 != 0) && (ccode2 != 3) && (!retry) ) { printk( " ... msch() retry count for " "subchannel %04X exceeded, CC = %d\n", irq, ccode2); } /* endif */ } else { /* no path available ... */ ioinfo[irq]->ui.flags.oper = 0; ret = -ENODEV; } /* endif */ } else { ret = -ENODEV; } /* endif */ } else { ret = -ENXIO; } /* endif */ return( ret ); } /* * s390_SenseID * * Try to obtain the 'control unit'/'device type' information * associated with the subchannel. * * The function is primarily meant to be called without irq * action handler in place. However, it also allows for * use with an action handler in place. If there is already * an action handler registered assure it can handle the * s390_SenseID() related device interrupts - interruption * parameter used is 0x00E2C9C4 ( SID ). */ int s390_SenseID( int irq, senseid_t *sid, __u8 lpm ) { ccw1_t *sense_ccw; /* ccw area for SenseID command */ senseid_t isid; /* internal sid */ devstat_t devstat; /* required by request_irq() */ __u8 pathmask; /* calulate path mask */ __u8 domask; /* path mask to use */ int inlreq; /* inline request_irq() */ int irq_ret; /* return code */ devstat_t *pdevstat; /* ptr to devstat in use */ int retry; /* retry count */ int io_retry; /* retry indicator */ senseid_t *psid = sid;/* start with the external buffer */ int sbuffer = 0; /* switch SID data buffer */ if ( (irq > highest_subchannel) || (irq < 0 ) ) { return( -ENODEV ); } else if ( ioinfo[irq] == INVALID_STORAGE_AREA ) { return( -ENODEV); } /* endif */ if ( ioinfo[irq]->ui.flags.oper == 0 ) { return( -ENODEV ); } /* endif */ if ( !ioinfo[irq]->ui.flags.ready ) { pdevstat = &devstat; /* * Perform SENSE ID command processing. We have to request device * ownership and provide a dummy I/O handler. We issue sync. I/O * requests and evaluate the devstat area on return therefore * we don't need a real I/O handler in place. */ irq_ret = request_irq( irq, init_IRQ_handler, 0, "SID", &devstat); if ( irq_ret == 0 ) inlreq = 1; } else { inlreq = 0; irq_ret = 0; pdevstat = ioinfo[irq]->irq_desc.action->dev_id; } /* endif */ if ( irq_ret == 0 ) { int i; s390irq_spin_lock( irq); if ( init_IRQ_complete ) { sense_ccw = kmalloc( 2*sizeof( ccw1_t), GFP_DMA); } else { sense_ccw = alloc_bootmem_low( 2*sizeof( ccw1_t)); } /* endif */ // more than one path installed ? if ( ioinfo[irq]->schib.pmcw.pim != 0x80 ) { sense_ccw[0].cmd_code = CCW_CMD_SUSPEND_RECONN; sense_ccw[0].cda = 0; sense_ccw[0].count = 0; sense_ccw[0].flags = CCW_FLAG_SLI | CCW_FLAG_CC; sense_ccw[1].cmd_code = CCW_CMD_SENSE_ID; sense_ccw[1].cda = (__u32)virt_to_phys( sid ); sense_ccw[1].count = sizeof( senseid_t); sense_ccw[1].flags = CCW_FLAG_SLI; } else { sense_ccw[0].cmd_code = CCW_CMD_SENSE_ID; sense_ccw[0].cda = (__u32)virt_to_phys( sid ); sense_ccw[0].count = sizeof( senseid_t); sense_ccw[0].flags = CCW_FLAG_SLI; } /* endif */ for ( i = 0 ; (i < 8) ; i++ ) { pathmask = 0x80 >> i; domask = ioinfo[irq]->opm & pathmask; if ( lpm ) domask &= lpm; if ( domask ) { psid->cu_type = 0xFFFF; /* initialize fields ... */ psid->cu_model = 0; psid->dev_type = 0; psid->dev_model = 0; retry = 5; /* retry count */ io_retry = 1; /* enable retries */ /* * We now issue a SenseID request. In case of BUSY, * STATUS PENDING or non-CMD_REJECT error conditions * we run simple retries. */ do { memset( pdevstat, '\0', sizeof( devstat_t) ); irq_ret = s390_start_IO( irq, sense_ccw, 0x00E2C9C4, // == SID domask, DOIO_WAIT_FOR_INTERRUPT | DOIO_TIMEOUT | DOIO_VALID_LPM | DOIO_DONT_CALL_INTHDLR ); // // The OSA_E FE card possibly causes -ETIMEDOUT // conditions, as the SenseID may stay start // pending. This will cause start_IO() to finally // halt the operation we should retry. If the halt // fails this may cause -EBUSY we simply retry // and eventually clean up with free_irq(). // if ( psid->cu_type == 0xFFFF ) { if ( pdevstat->flag & DEVSTAT_STATUS_PENDING ) { #ifdef CONFIG_DEBUG_IO printk( "SenseID : device %04X on " "Subchannel %04X " "reports pending status, " "retry : %d\n", ioinfo[irq]->schib.pmcw.dev, irq, retry); #endif } /* endif */ if ( pdevstat->flag & DEVSTAT_FLAG_SENSE_AVAIL ) { /* * if the device doesn't support the SenseID * command further retries wouldn't help ... */ if ( pdevstat->ii.sense.data[0] & (SNS0_CMD_REJECT | SNS0_INTERVENTION_REQ) ) { #ifdef CONFIG_DEBUG_IO printk( "SenseID : device %04X on " "Subchannel %04X " "reports cmd reject or " "intervention required\n", ioinfo[irq]->schib.pmcw.dev, irq); #endif io_retry = 1; } #ifdef CONFIG_DEBUG_IO else { printk( "SenseID : UC on " "dev %04X, " "retry %d, " "lpum %02X, " "cnt %02d, " "sns :" " %02X%02X%02X%02X " "%02X%02X%02X%02X ...\n", ioinfo[irq]->schib.pmcw.dev, retry, pdevstat->lpum, pdevstat->scnt, pdevstat->ii.sense.data[0], pdevstat->ii.sense.data[1], pdevstat->ii.sense.data[2], pdevstat->ii.sense.data[3], pdevstat->ii.sense.data[4], pdevstat->ii.sense.data[5], pdevstat->ii.sense.data[6], pdevstat->ii.sense.data[7]); } /* endif */ #endif } else if ( ( pdevstat->flag & DEVSTAT_NOT_OPER ) || ( irq_ret == -ENODEV ) ) { #ifdef CONFIG_DEBUG_IO printk( "SenseID : path %02X for " "device %04X on " "subchannel %04X " "is 'not operational'\n", domask, ioinfo[irq]->schib.pmcw.dev, irq); #endif io_retry = 0; ioinfo[irq]->opm &= ~domask; } #ifdef CONFIG_DEBUG_IO else if ( (pdevstat->flag != ( DEVSTAT_START_FUNCTION | DEVSTAT_FINAL_STATUS ) ) && !(pdevstat->flag & DEVSTAT_STATUS_PENDING ) ) { printk( "SenseID : start_IO() for " "device %04X on " "subchannel %04X " "returns %d, retry %d, " "status %04X\n", ioinfo[irq]->schib.pmcw.dev, irq, irq_ret, retry, pdevstat->flag); } /* endif */ #endif } else // we got it ... { if ( !sbuffer ) // switch buffers { /* * we report back the * first hit only */ psid = &isid; if ( ioinfo[irq]->schib.pmcw.pim != 0x80 ) { sense_ccw[1].cda = (__u32)virt_to_phys( psid ); } else { sense_ccw[0].cda = (__u32)virt_to_phys( psid ); } /* endif */ /* * if just the very first * was requested to be * sensed disable further * scans. */ if ( !lpm ) lpm = domask; sbuffer = 1; } /* endif */ if ( pdevstat->rescnt < (sizeof( senseid_t) - 8) ) { ioinfo[irq]->ui.flags.esid = 1; } /* endif */ io_retry = 0; } /* endif */ if ( io_retry ) { retry--; if ( retry == 0 ) { io_retry = 0; } /* endif */ } /* endif */ } while ( (io_retry) ); } /* endif - domask */ } /* endfor */ if ( init_IRQ_complete ) { kfree( sense_ccw ); } else { free_bootmem( (unsigned long)sense_ccw, 2*sizeof(ccw1_t) ); } /* endif */ s390irq_spin_unlock( irq); /* * If we installed the irq action handler we have to * release it too. */ if ( inlreq ) free_irq( irq, pdevstat); /* * if running under VM check there ... perhaps we should do * only if we suffered a command reject, but it doesn't harm */ if ( ( sid->cu_type == 0xFFFF ) && ( MACHINE_IS_VM ) ) { VM_virtual_device_info( ioinfo[irq]->schib.pmcw.dev, sid ); } /* endif */ if ( sid->cu_type == 0xFFFF ) { /* * SenseID CU-type of 0xffff indicates that no device * information could be retrieved (pre-init value). * * If we can't couldn't identify the device type we * consider the device "not operational". */ #ifdef CONFIG_DEBUG_IO printk( "SenseID : unknown device %04X on subchannel %04X\n", ioinfo[irq]->schib.pmcw.dev, irq); #endif ioinfo[irq]->ui.flags.unknown = 1; } /* endif */ if ( cio_show_msg ) { /* * Issue device info message if unit was operational . */ if ( !ioinfo[irq]->ui.flags.unknown ) { if ( sid->dev_type != 0 ) { printk( KERN_INFO"SenseID : device %04X reports: " "CU Type/Mod = %04X/%02X," " Dev Type/Mod = %04X/%02X\n", ioinfo[irq]->schib.pmcw.dev, sid->cu_type, sid->cu_model, sid->dev_type, sid->dev_model); } else { printk( KERN_INFO"SenseID : device %04X reports:" " Dev Type/Mod = %04X/%02X\n", ioinfo[irq]->schib.pmcw.dev, sid->cu_type, sid->cu_model); } /* endif */ } /* endif */ } /* endif */ if ( !ioinfo[irq]->ui.flags.unknown ) irq_ret = 0; else irq_ret = -ENODEV; } /* endif */ return( irq_ret ); } static int __inline__ s390_SetMultiPath( int irq ) { int cc; cc = stsch( irq, &ioinfo[irq]->schib ); if ( !cc ) { ioinfo[irq]->schib.pmcw.mp = 1; /* multipath mode */ cc = msch( irq, &ioinfo[irq]->schib ); } /* endif */ return( cc); } /* * Device Path Verification * * Path verification is accomplished by checking which paths (CHPIDs) are * available. Further, a path group ID is set, if possible in multipath * mode, otherwise in single path mode. * */ int s390_DevicePathVerification( int irq, __u8 usermask ) { #if 1 int ccode; __u8 pathmask; __u8 domask; int ret = 0; if ( ioinfo[irq]->ui.flags.pgid_supp == 0 ) { return( 0); // just exit ... } /* endif */ ccode = stsch( irq, &(ioinfo[irq]->schib) ); if ( ccode ) { ret = -ENODEV; } else if ( ioinfo[irq]->schib.pmcw.pim == 0x80 ) { /* * no error, just not required for single path only devices */ ioinfo[irq]->ui.flags.pgid_supp = 0; ret = 0; } else { int i; pgid_t pgid; __u8 dev_path; int first = 1; ioinfo[irq]->opm = ioinfo[irq]->schib.pmcw.pim & ioinfo[irq]->schib.pmcw.pam & ioinfo[irq]->schib.pmcw.pom; if ( usermask ) { dev_path = usermask; } else { dev_path = ioinfo[irq]->opm; } /* endif */ /* * let's build a path group ID if we don't have one yet */ if ( ioinfo[irq]->ui.flags.pgid == 0) { ioinfo[irq]->pgid.cpu_addr = *(__u16 *)__LC_CPUADDR; ioinfo[irq]->pgid.cpu_id = ((cpuid_t *)__LC_CPUID)->ident; ioinfo[irq]->pgid.cpu_model = ((cpuid_t *)__LC_CPUID)->machine; ioinfo[irq]->pgid.tod_high = *(__u32 *)&irq_IPL_TOD; ioinfo[irq]->ui.flags.pgid = 1; } /* endif */ memcpy( &pgid, &ioinfo[irq]->pgid, sizeof(pgid_t)); for ( i = 0; i < 8 && !ret ; i++) { pathmask = 0x80 >> i; domask = dev_path & pathmask; if ( domask ) { ret = s390_SetPGID( irq, domask, &pgid ); /* * For the *first* path we are prepared * for recovery * * - If we fail setting the PGID we assume its * using a different PGID already (VM) we * try to sense. */ if ( ret == -EOPNOTSUPP && first ) { *(int *)&pgid = 0; ret = s390_SensePGID( irq, domask, &pgid); first = 0; if ( ret == 0 ) { /* * Check whether we retrieved * a reasonable PGID ... */ if ( pgid.inf.ps.state1 == SNID_STATE1_GROUPED ) { memcpy( &(ioinfo[irq]->pgid), &pgid, sizeof(pgid_t) ); } else // ungrouped or garbage ... { ret = -EOPNOTSUPP; } /* endif */ } else { ioinfo[irq]->ui.flags.pgid_supp = 0; #ifdef CONFIG_DEBUG_IO printk( "PathVerification(%04X) " "- Device %04X doesn't " " support path grouping\n", irq, ioinfo[irq]->schib.pmcw.dev); #endif } /* endif */ } else if ( ret ) { #ifdef CONFIG_DEBUG_IO printk( "PathVerification(%04X) " "- Device %04X doesn't " " support path grouping\n", irq, ioinfo[irq]->schib.pmcw.dev); #endif ioinfo[irq]->ui.flags.pgid_supp = 0; } /* endif */ } /* endif */ } /* endfor */ } /* endif */ return ret; #else return 0; #endif } /* * s390_SetPGID * * Set Path Group ID * */ int s390_SetPGID( int irq, __u8 lpm, pgid_t *pgid ) { ccw1_t *spid_ccw; /* ccw area for SPID command */ devstat_t devstat; /* required by request_irq() */ devstat_t *pdevstat = &devstat; int irq_ret = 0; /* return code */ int retry = 5; /* retry count */ int inlreq = 0; /* inline request_irq() */ int mpath = 1; /* try multi-path first */ if ( (irq > highest_subchannel) || (irq < 0 ) ) { return( -ENODEV ); } else if ( ioinfo[irq] == INVALID_STORAGE_AREA ) { return( -ENODEV); } /* endif */ if ( ioinfo[irq]->ui.flags.oper == 0 ) { return( -ENODEV ); } /* endif */ if ( !ioinfo[irq]->ui.flags.ready ) { /* * Perform SENSE ID command processing. We have to request device * ownership and provide a dummy I/O handler. We issue sync. I/O * requests and evaluate the devstat area on return therefore * we don't need a real I/O handler in place. */ irq_ret = request_irq( irq, init_IRQ_handler, 0, "SPID", pdevstat); if ( irq_ret == 0 ) inlreq = 1; } else { pdevstat = ioinfo[irq]->irq_desc.action->dev_id; } /* endif */ if ( irq_ret == 0 ) { s390irq_spin_lock( irq); if ( init_IRQ_complete ) { spid_ccw = kmalloc( 2*sizeof( ccw1_t), GFP_DMA); } else { spid_ccw = alloc_bootmem_low( 2*sizeof( ccw1_t)); } /* endif */ spid_ccw[0].cmd_code = 0x5B; /* suspend multipath reconnect */ spid_ccw[0].cda = 0; spid_ccw[0].count = 0; spid_ccw[0].flags = CCW_FLAG_SLI | CCW_FLAG_CC; spid_ccw[1].cmd_code = CCW_CMD_SET_PGID; spid_ccw[1].cda = (__u32)virt_to_phys( pgid ); spid_ccw[1].count = sizeof( pgid_t); spid_ccw[1].flags = CCW_FLAG_SLI; pgid->inf.fc = SPID_FUNC_MULTI_PATH | SPID_FUNC_ESTABLISH; /* * We now issue a SenseID request. In case of BUSY * or STATUS PENDING conditions we retry 5 times. */ do { memset( pdevstat, '\0', sizeof( devstat_t) ); irq_ret = s390_start_IO( irq, spid_ccw, 0xE2D7C9C4, // == SPID lpm, // n/a DOIO_WAIT_FOR_INTERRUPT | DOIO_VALID_LPM | DOIO_DONT_CALL_INTHDLR ); if ( !irq_ret ) { if ( pdevstat->flag & DEVSTAT_STATUS_PENDING ) { #ifdef CONFIG_DEBUG_IO printk( "SPID - Device %04X " "on Subchannel %04X " "reports pending status, " "retry : %d\n", ioinfo[irq]->schib.pmcw.dev, irq, retry); #endif } /* endif */ if ( pdevstat->flag == ( DEVSTAT_START_FUNCTION | DEVSTAT_FINAL_STATUS ) ) { retry = 0; // successfully set ... } else if ( pdevstat->flag & DEVSTAT_FLAG_SENSE_AVAIL ) { /* * If the device doesn't support the * Sense Path Group ID command * further retries wouldn't help ... */ if ( pdevstat->ii.sense.data[0] & SNS0_CMD_REJECT ) { if ( mpath ) { pgid->inf.fc = SPID_FUNC_SINGLE_PATH | SPID_FUNC_ESTABLISH; mpath = 0; retry--; } else { irq_ret = -EOPNOTSUPP; retry = 0; } /* endif */ } #ifdef CONFIG_DEBUG_IO else { printk( "SPID - device %04X," " unit check," " retry %d, cnt %02d," " sns :" " %02X%02X%02X%02X %02X%02X%02X%02X ...\n", ioinfo[irq]->schib.pmcw.dev, retry, pdevstat->scnt, pdevstat->ii.sense.data[0], pdevstat->ii.sense.data[1], pdevstat->ii.sense.data[2], pdevstat->ii.sense.data[3], pdevstat->ii.sense.data[4], pdevstat->ii.sense.data[5], pdevstat->ii.sense.data[6], pdevstat->ii.sense.data[7]); } /* endif */ #endif } else if ( pdevstat->flag & DEVSTAT_NOT_OPER ) { printk( "SPID - Device %04X " "on Subchannel %04X " "became 'not operational'\n", ioinfo[irq]->schib.pmcw.dev, irq); retry = 0; } /* endif */ } else if ( irq_ret != -ENODEV ) { retry--; } else { retry = 0; } /* endif */ } while ( retry > 0 ); if ( init_IRQ_complete ) { kfree( spid_ccw ); } else { free_bootmem( (unsigned long)spid_ccw, 2*sizeof(ccw1_t) ); } /* endif */ s390irq_spin_unlock( irq); /* * If we installed the irq action handler we have to * release it too. */ if ( inlreq ) free_irq( irq, pdevstat); } /* endif */ return( irq_ret ); } /* * s390_SensePGID * * Sense Path Group ID * */ int s390_SensePGID( int irq, __u8 lpm, pgid_t *pgid ) { ccw1_t *snid_ccw; /* ccw area for SNID command */ devstat_t devstat; /* required by request_irq() */ devstat_t *pdevstat = &devstat; int irq_ret = 0; /* return code */ int retry = 5; /* retry count */ int inlreq = 0; /* inline request_irq() */ if ( (irq > highest_subchannel) || (irq < 0 ) ) { return( -ENODEV ); } else if ( ioinfo[irq] == INVALID_STORAGE_AREA ) { return( -ENODEV); } /* endif */ if ( ioinfo[irq]->ui.flags.oper == 0 ) { return( -ENODEV ); } /* endif */ if ( !ioinfo[irq]->ui.flags.ready ) { /* * Perform SENSE ID command processing. We have to request device * ownership and provide a dummy I/O handler. We issue sync. I/O * requests and evaluate the devstat area on return therefore * we don't need a real I/O handler in place. */ irq_ret = request_irq( irq, init_IRQ_handler, 0, "SNID", pdevstat); if ( irq_ret == 0 ) inlreq = 1; } else { pdevstat = ioinfo[irq]->irq_desc.action->dev_id; } /* endif */ if ( irq_ret == 0 ) { s390irq_spin_lock( irq); if ( init_IRQ_complete ) { snid_ccw = kmalloc( sizeof( ccw1_t), GFP_DMA); } else { snid_ccw = alloc_bootmem_low( sizeof( ccw1_t)); } /* endif */ snid_ccw->cmd_code = CCW_CMD_SENSE_PGID; snid_ccw->cda = (__u32)virt_to_phys( pgid ); snid_ccw->count = sizeof( pgid_t); snid_ccw->flags = CCW_FLAG_SLI; /* * We now issue a SenseID request. In case of BUSY * or STATUS PENDING conditions we retry 5 times. */ do { memset( pdevstat, '\0', sizeof( devstat_t) ); irq_ret = s390_start_IO( irq, snid_ccw, 0xE2D5C9C4, // == SNID lpm, // n/a DOIO_WAIT_FOR_INTERRUPT | DOIO_VALID_LPM | DOIO_DONT_CALL_INTHDLR ); if ( irq_ret == 0 ) { if ( pdevstat->flag & DEVSTAT_FLAG_SENSE_AVAIL ) { /* * If the device doesn't support the * Sense Path Group ID command * further retries wouldn't help ... */ if ( pdevstat->ii.sense.data[0] & SNS0_CMD_REJECT ) { retry = 0; irq_ret = -EOPNOTSUPP; } else { #ifdef CONFIG_DEBUG_IO printk( "SNID - device %04X," " unit check," " flag %04X, " " retry %d, cnt %02d," " sns :" " %02X%02X%02X%02X %02X%02X%02X%02X ...\n", ioinfo[irq]->schib.pmcw.dev, pdevstat->flag, retry, pdevstat->scnt, pdevstat->ii.sense.data[0], pdevstat->ii.sense.data[1], pdevstat->ii.sense.data[2], pdevstat->ii.sense.data[3], pdevstat->ii.sense.data[4], pdevstat->ii.sense.data[5], pdevstat->ii.sense.data[6], pdevstat->ii.sense.data[7]); #endif retry--; } /* endif */ } else if ( pdevstat->flag & DEVSTAT_NOT_OPER ) { printk( "SNID - Device %04X " "on Subchannel %04X " "became 'not operational'\n", ioinfo[irq]->schib.pmcw.dev, irq); retry = 0; } else { retry = 0; // success ... } /* endif */ } else if ( irq_ret != -ENODEV ) // -EIO, or -EBUSY { #ifdef CONFIG_DEBUG_IO if ( pdevstat->flag & DEVSTAT_STATUS_PENDING ) { printk( "SNID - Device %04X " "on Subchannel %04X " "reports pending status, " "retry : %d\n", ioinfo[irq]->schib.pmcw.dev, irq, retry); } /* endif */ #endif printk( "SNID - device %04X," " start_io() reports rc : %d, retrying ...\n", ioinfo[irq]->schib.pmcw.dev, irq_ret); retry--; } else // -ENODEV ... { retry = 0; } /* endif */ } while ( retry > 0 ); if ( init_IRQ_complete ) { kfree( snid_ccw ); } else { free_bootmem( (unsigned long)snid_ccw, sizeof(ccw1_t) ); } /* endif */ s390irq_spin_unlock( irq); /* * If we installed the irq action handler we have to * release it too. */ if ( inlreq ) free_irq( irq, pdevstat); } /* endif */ return( irq_ret ); } /* * s390_do_crw_pending * * Called by the machine check handler to process CRW pending * conditions. It may be a single CRW, or CRWs may be chained. * * Note : we currently process CRWs for subchannel source only */ void s390_do_crw_pending( crwe_t *pcrwe ) { int irq; int chpid; int dev_oper = 0; int dev_no = -1; int lock = 0; #ifdef CONFIG_DEBUG_CRW printk( "do_crw_pending : starting ...\n"); #endif while ( pcrwe != NULL ) { int is_owned = 0; switch ( pcrwe->crw.rsc ) { case CRW_RSC_SCH : irq = pcrwe->crw.rsid; #ifdef CONFIG_DEBUG_CRW printk( KERN_INFO"do_crw_pending : source is " "subchannel %04X\n", irq); #endif /* * If the device isn't known yet * we can't lock it ... */ if ( ioinfo[irq] != INVALID_STORAGE_AREA ) { s390irq_spin_lock( irq ); lock = 1; dev_oper = ioinfo[irq]->ui.flags.oper; if ( ioinfo[irq]->ui.flags.dval ) dev_no = ioinfo[irq]->devno; is_owned = ioinfo[irq]->ui.flags.ready; } /* endif */ #ifdef CONFIG_DEBUG_CRW printk( "do_crw_pending : subchannel validation - start ...\n"); #endif s390_validate_subchannel( irq, is_owned ); if ( irq > highest_subchannel ) highest_subchannel = irq; #ifdef CONFIG_DEBUG_CRW printk( "do_crw_pending : subchannel validation - done\n"); #endif /* * After the validate processing * the ioinfo control block * should be allocated ... */ if ( lock ) { s390irq_spin_unlock( irq ); } /* endif */ #ifdef CONFIG_DEBUG_CRW if ( ioinfo[irq] != INVALID_STORAGE_AREA ) { printk( "do_crw_pending : ioinfo at %08X\n", (unsigned)ioinfo[irq]); } /* endif */ #endif if ( ioinfo[irq] != INVALID_STORAGE_AREA ) { if ( ioinfo[irq]->ui.flags.oper == 0 ) { not_oper_handler_func_t nopfunc=ioinfo[irq]->nopfunc; /* * If the device has gone * call not oper handler */ if ( ( dev_oper == 1 ) && ( nopfunc != NULL ) ) { free_irq( irq,ioinfo[irq]->irq_desc.action->dev_id ); nopfunc( irq,DEVSTAT_DEVICE_GONE ); } /* endif */ } else { #ifdef CONFIG_DEBUG_CRW printk( "do_crw_pending : device " "recognition - start ...\n"); #endif s390_device_recognition_irq( irq ); #ifdef CONFIG_DEBUG_CRW printk( "do_crw_pending : device " "recognition - done\n"); #endif /* * the device became operational */ if ( dev_oper == 0 ) { devreg_t *pdevreg; pdevreg = s390_search_devreg( ioinfo[irq] ); if ( pdevreg != NULL ) { if ( pdevreg->oper_func != NULL ) pdevreg->oper_func( irq, pdevreg ); } /* endif */ } /* * ... it is and was operational, but * the devno may have changed */ else if ((ioinfo[irq]->devno != dev_no) && ( ioinfo[irq]->nopfunc != NULL )) { ioinfo[irq]->nopfunc( irq, DEVSTAT_REVALIDATE ); } /* endif */ } /* endif */ } /* endif */ break; case CRW_RSC_MONITOR : #ifdef CONFIG_DEBUG_CRW printk( "do_crw_pending : source is " "monitoring facility\n"); #endif break; case CRW_RSC_CPATH : chpid = pcrwe->crw.rsid; #ifdef CONFIG_DEBUG_CRW printk( "do_crw_pending : source is " "channel path %02X\n", chpid); #endif break; case CRW_RSC_CONFIG : #ifdef CONFIG_DEBUG_CRW printk( "do_crw_pending : source is " "configuration-alert facility\n"); #endif break; case CRW_RSC_CSS : #ifdef CONFIG_DEBUG_CRW printk( "do_crw_pending : source is " "channel subsystem\n"); #endif break; default : #ifdef CONFIG_DEBUG_CRW printk( "do_crw_pending : unknown source\n"); #endif break; } /* endswitch */ pcrwe = pcrwe->crwe_next; } /* endwhile */ #ifdef CONFIG_DEBUG_CRW printk( "do_crw_pending : done\n"); #endif return; } /* added by Holger Smolinski for reipl support in reipl.S */ extern void do_reipl (int); void reipl ( int sch ) { int i; for ( i = 0; i < highest_subchannel; i ++ ) { free_irq ( i, (void*)REIPL_DEVID_MAGIC ); } do_reipl( 0x10000 | sch ); }