Merge ../linux-2.6

13 files changed, 263 insertions, 54 deletions

diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 7a85b3a26ff8..889cad07774e 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -713,7 +713,7 @@ config NVRAM
 
 config RTC
         tristate "Enhanced Real Time Clock Support"
-        depends on !PPC && !PARISC && !IA64 && !M68K && (!SPARC || PCI) && !FRV
+        depends on !PPC && !PARISC && !IA64 && !M68K && (!SPARC || PCI) && !FRV && !ARM
         ---help---
           If you say Y here and create a character special file /dev/rtc with
           major number 10 and minor number 135 using mknod ("man mknod"), you
diff --git a/drivers/char/agp/nvidia-agp.c b/drivers/char/agp/nvidia-agp.c
index 70b8ed9cd172..4c67135c12d8 100644
--- a/drivers/char/agp/nvidia-agp.c
+++ b/drivers/char/agp/nvidia-agp.c
@@ -11,6 +11,7 @@
 #include <linux/gfp.h>
 #include <linux/page-flags.h>
 #include <linux/mm.h>
+#include <linux/jiffies.h>
 #include "agp.h"
 
 /* NVIDIA registers */
@@ -256,7 +257,7 @@ static void nvidia_tlbflush(struct agp_memory *mem)
                 do {
                         pci_read_config_dword(nvidia_private.dev_1,
                                         NVIDIA_1_WBC, &wbc_reg);
-                        if ((signed)(end - jiffies) <= 0) {
+                        if (time_before_eq(end, jiffies)) {
                                 printk(KERN_ERR PFX
                                     "TLB flush took more than 3 seconds.\n");
                         }
diff --git a/drivers/char/drm/drm_fops.c b/drivers/char/drm/drm_fops.c
index 641f7633878c..b7f7951c4587 100644
--- a/drivers/char/drm/drm_fops.c
+++ b/drivers/char/drm/drm_fops.c
@@ -175,7 +175,7 @@ int drm_stub_open(struct inode *inode, struct file *filp)
         drm_device_t *dev = NULL;
         int minor = iminor(inode);
         int err = -ENODEV;
-        struct file_operations *old_fops;
+        const struct file_operations *old_fops;
 
         DRM_DEBUG("\n");
 
diff --git a/drivers/char/drm/i810_dma.c b/drivers/char/drm/i810_dma.c
index ae0aa6d7e0bb..c658dde3633b 100644
--- a/drivers/char/drm/i810_dma.c
+++ b/drivers/char/drm/i810_dma.c
@@ -126,7 +126,7 @@ static int i810_map_buffer(drm_buf_t * buf, struct file *filp)
         drm_device_t *dev = priv->head->dev;
         drm_i810_buf_priv_t *buf_priv = buf->dev_private;
         drm_i810_private_t *dev_priv = dev->dev_private;
-        struct file_operations *old_fops;
+        const struct file_operations *old_fops;
         int retcode = 0;
 
         if (buf_priv->currently_mapped == I810_BUF_MAPPED)
diff --git a/drivers/char/drm/i830_dma.c b/drivers/char/drm/i830_dma.c
index 163f2cbfe60d..b0f815d8cea8 100644
--- a/drivers/char/drm/i830_dma.c
+++ b/drivers/char/drm/i830_dma.c
@@ -128,7 +128,7 @@ static int i830_map_buffer(drm_buf_t * buf, struct file *filp)
         drm_device_t *dev = priv->head->dev;
         drm_i830_buf_priv_t *buf_priv = buf->dev_private;
         drm_i830_private_t *dev_priv = dev->dev_private;
-        struct file_operations *old_fops;
+        const struct file_operations *old_fops;
         unsigned long virtual;
         int retcode = 0;
 
diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
index b8fb87c6c29f..40eb005b9d77 100644
--- a/drivers/char/ipmi/ipmi_msghandler.c
+++ b/drivers/char/ipmi/ipmi_msghandler.c
@@ -3744,7 +3744,7 @@ static int ipmi_init_msghandler(void)
         ipmi_timer.expires = jiffies + IPMI_TIMEOUT_JIFFIES;
         add_timer(&ipmi_timer);
 
-        notifier_chain_register(&panic_notifier_list, &panic_block);
+        atomic_notifier_chain_register(&panic_notifier_list, &panic_block);
 
         initialized = 1;
 
@@ -3764,7 +3764,7 @@ static __exit void cleanup_ipmi(void)
         if (!initialized)
                 return;
 
-        notifier_chain_unregister(&panic_notifier_list, &panic_block);
+        atomic_notifier_chain_unregister(&panic_notifier_list, &panic_block);
 
         /* This can't be called if any interfaces exist, so no worry about
            shutting down the interfaces. */
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index 12f858dc9994..35fbd4d8ed4b 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -237,10 +237,10 @@ struct smi_info
 
 static int try_smi_init(struct smi_info *smi);
 
-static struct notifier_block *xaction_notifier_list;
+static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
 static int register_xaction_notifier(struct notifier_block * nb)
 {
-        return notifier_chain_register(&xaction_notifier_list, nb);
+        return atomic_notifier_chain_register(&xaction_notifier_list, nb);
 }
 
 static void si_restart_short_timer(struct smi_info *smi_info);
@@ -302,7 +302,8 @@ static enum si_sm_result start_next_msg(struct smi_info *smi_info)
                 do_gettimeofday(&t);
                 printk("**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
 #endif
-                err = notifier_call_chain(&xaction_notifier_list, 0, smi_info);
+                err = atomic_notifier_call_chain(&xaction_notifier_list,
+                                0, smi_info);
                 if (err & NOTIFY_STOP_MASK) {
                         rv = SI_SM_CALL_WITHOUT_DELAY;
                         goto out;
diff --git a/drivers/char/ipmi/ipmi_watchdog.c b/drivers/char/ipmi/ipmi_watchdog.c
index 616539310d9a..7ece9f3c8f70 100644
--- a/drivers/char/ipmi/ipmi_watchdog.c
+++ b/drivers/char/ipmi/ipmi_watchdog.c
@@ -1158,7 +1158,8 @@ static int __init ipmi_wdog_init(void)
         }
 
         register_reboot_notifier(&wdog_reboot_notifier);
-        notifier_chain_register(&panic_notifier_list, &wdog_panic_notifier);
+        atomic_notifier_chain_register(&panic_notifier_list,
+                        &wdog_panic_notifier);
 
         printk(KERN_INFO PFX "driver initialized\n");
 
@@ -1176,7 +1177,8 @@ static __exit void ipmi_unregister_watchdog(void)
                 release_nmi(&ipmi_nmi_handler);
 #endif
 
-        notifier_chain_unregister(&panic_notifier_list, &wdog_panic_notifier);
+        atomic_notifier_chain_unregister(&panic_notifier_list,
+                        &wdog_panic_notifier);
         unregister_reboot_notifier(&wdog_reboot_notifier);
 
         if (! watchdog_user)
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index 5245ba1649ed..66719f9d294c 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -899,7 +899,7 @@ static const struct {
         unsigned int            minor;
         char                    *name;
         umode_t                 mode;
-        struct file_operations  *fops;
+        const struct file_operations    *fops;
 } devlist[] = { /* list of minor devices */
         {1, "mem",     S_IRUSR | S_IWUSR | S_IRGRP, &mem_fops},
         {2, "kmem",    S_IRUSR | S_IWUSR | S_IRGRP, &kmem_fops},
diff --git a/drivers/char/misc.c b/drivers/char/misc.c
index 3e4c0414a01a..96eb2a709e21 100644
--- a/drivers/char/misc.c
+++ b/drivers/char/misc.c
@@ -129,7 +129,7 @@ static int misc_open(struct inode * inode, struct file * file)
         int minor = iminor(inode);
         struct miscdevice *c;
         int err = -ENODEV;
-        struct file_operations *old_fops, *new_fops = NULL;
+        const struct file_operations *old_fops, *new_fops = NULL;
         
         down(&misc_sem);
         
diff --git a/drivers/char/mxser.h b/drivers/char/mxser.h
index e7fd0b08e0b7..7e188a4d602a 100644
--- a/drivers/char/mxser.h
+++ b/drivers/char/mxser.h
@@ -118,7 +118,7 @@
 
 // enable CTS interrupt
 #define MOXA_MUST_IER_ECTSI             0x80
-// eanble RTS interrupt
+// enable RTS interrupt
 #define MOXA_MUST_IER_ERTSI             0x40
 // enable Xon/Xoff interrupt
 #define MOXA_MUST_IER_XINT              0x20
diff --git a/drivers/char/synclink.c b/drivers/char/synclink.c
index d68be61f0a49..fee2aca3f6a5 100644
--- a/drivers/char/synclink.c
+++ b/drivers/char/synclink.c
@@ -941,17 +941,6 @@ static void* mgsl_get_text_ptr(void)
         return mgsl_get_text_ptr;
 }
 
-/*
- * tmp_buf is used as a temporary buffer by mgsl_write.  We need to
- * lock it in case the COPY_FROM_USER blocks while swapping in a page,
- * and some other program tries to do a serial write at the same time.
- * Since the lock will only come under contention when the system is
- * swapping and available memory is low, it makes sense to share one
- * buffer across all the serial ioports, since it significantly saves
- * memory if large numbers of serial ports are open.
- */
-static unsigned char *tmp_buf;
-
 static inline int mgsl_paranoia_check(struct mgsl_struct *info,
                                         char *name, const char *routine)
 {
@@ -2150,7 +2139,7 @@ static int mgsl_write(struct tty_struct * tty,
         if (mgsl_paranoia_check(info, tty->name, "mgsl_write"))
                 goto cleanup;
 
-        if (!tty || !info->xmit_buf || !tmp_buf)
+        if (!tty || !info->xmit_buf)
                 goto cleanup;
 
         if ( info->params.mode == MGSL_MODE_HDLC ||
@@ -3438,7 +3427,6 @@ static int mgsl_open(struct tty_struct *tty, struct file * filp)
 {
         struct mgsl_struct      *info;
         int                     retval, line;
-        unsigned long           page;
         unsigned long flags;
 
         /* verify range of specified line number */     
@@ -3472,18 +3460,6 @@ static int mgsl_open(struct tty_struct *tty, struct file * filp)
                 goto cleanup;
         }
         
-        if (!tmp_buf) {
-                page = get_zeroed_page(GFP_KERNEL);
-                if (!page) {
-                        retval = -ENOMEM;
-                        goto cleanup;
-                }
-                if (tmp_buf)
-                        free_page(page);
-                else
-                        tmp_buf = (unsigned char *) page;
-        }
-        
         info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
 
         spin_lock_irqsave(&info->netlock, flags);
@@ -4502,11 +4478,6 @@ static void synclink_cleanup(void)
                 kfree(tmp);
         }
         
-        if (tmp_buf) {
-                free_page((unsigned long) tmp_buf);
-                tmp_buf = NULL;
-        }
-        
         if (pci_registered)
                 pci_unregister_driver(&synclink_pci_driver);
 }
@@ -6025,7 +5996,7 @@ static void usc_set_async_mode( struct mgsl_struct *info )
          * <15..8>      ?               RxFIFO IRQ Request Level
          *
          * Note: For async mode the receive FIFO level must be set
-         * to 0 to aviod the situation where the FIFO contains fewer bytes
+         * to 0 to avoid the situation where the FIFO contains fewer bytes
          * than the trigger level and no more data is expected.
          *
          * <7>          0               Exited Hunt IA (Interrupt Arm)
diff --git a/drivers/char/synclink_gt.c b/drivers/char/synclink_gt.c
index 738ec2f4e563..b4d1f4eea435 100644
--- a/drivers/char/synclink_gt.c
+++ b/drivers/char/synclink_gt.c
@@ -1,5 +1,5 @@
 /*
- * $Id: synclink_gt.c,v 4.22 2006/01/09 20:16:06 paulkf Exp $
+ * $Id: synclink_gt.c,v 4.25 2006/02/06 21:20:33 paulkf Exp $
  *
  * Device driver for Microgate SyncLink GT serial adapters.
  *
@@ -92,7 +92,7 @@
  * module identification
  */
 static char *driver_name     = "SyncLink GT";
-static char *driver_version  = "$Revision: 4.22 $";
+static char *driver_version  = "$Revision: 4.25 $";
 static char *tty_driver_name = "synclink_gt";
 static char *tty_dev_prefix  = "ttySLG";
 MODULE_LICENSE("GPL");
@@ -188,6 +188,20 @@ static void hdlcdev_exit(struct slgt_info *info);
 #define SLGT_REG_SIZE  256
 
 /*
+ * conditional wait facility
+ */
+struct cond_wait {
+        struct cond_wait *next;
+        wait_queue_head_t q;
+        wait_queue_t wait;
+        unsigned int data;
+};
+static void init_cond_wait(struct cond_wait *w, unsigned int data);
+static void add_cond_wait(struct cond_wait **head, struct cond_wait *w);
+static void remove_cond_wait(struct cond_wait **head, struct cond_wait *w);
+static void flush_cond_wait(struct cond_wait **head);
+
+/*
  * DMA buffer descriptor and access macros
  */
 struct slgt_desc
@@ -269,6 +283,9 @@ struct slgt_info {
         struct timer_list       tx_timer;
         struct timer_list       rx_timer;
 
+        unsigned int            gpio_present;
+        struct cond_wait        *gpio_wait_q;
+
         spinlock_t lock;        /* spinlock for synchronizing with ISR */
 
         struct work_struct task;
@@ -379,6 +396,11 @@ static MGSL_PARAMS default_params = {
 #define MASK_OVERRUN BIT4
 
 #define GSR   0x00 /* global status */
+#define JCR   0x04 /* JTAG control */
+#define IODR  0x08 /* GPIO direction */
+#define IOER  0x0c /* GPIO interrupt enable */
+#define IOVR  0x10 /* GPIO value */
+#define IOSR  0x14 /* GPIO interrupt status */
 #define TDR   0x80 /* tx data */
 #define RDR   0x80 /* rx data */
 #define TCR   0x82 /* tx control */
@@ -503,6 +525,9 @@ static int  tiocmset(struct tty_struct *tty, struct file *file,
 static void set_break(struct tty_struct *tty, int break_state);
 static int  get_interface(struct slgt_info *info, int __user *if_mode);
 static int  set_interface(struct slgt_info *info, int if_mode);
+static int  set_gpio(struct slgt_info *info, struct gpio_desc __user *gpio);
+static int  get_gpio(struct slgt_info *info, struct gpio_desc __user *gpio);
+static int  wait_gpio(struct slgt_info *info, struct gpio_desc __user *gpio);
 
 /*
  * driver functions
@@ -1112,6 +1137,12 @@ static int ioctl(struct tty_struct *tty, struct file *file,
                 return get_interface(info, argp);
         case MGSL_IOCSIF:
                 return set_interface(info,(int)arg);
+        case MGSL_IOCSGPIO:
+                return set_gpio(info, argp);
+        case MGSL_IOCGGPIO:
+                return get_gpio(info, argp);
+        case MGSL_IOCWAITGPIO:
+                return wait_gpio(info, argp);
         case TIOCGICOUNT:
                 spin_lock_irqsave(&info->lock,flags);
                 cnow = info->icount;
@@ -1762,10 +1793,6 @@ static void rx_async(struct slgt_info *info)
                 DBGDATA(info, p, count, "rx");
 
                 for(i=0 ; i < count; i+=2, p+=2) {
-                        if (tty && chars) {
-                                tty_flip_buffer_push(tty);
-                                chars = 0;
-                        }
                         ch = *p;
                         icount->rx++;
 
@@ -2158,6 +2185,24 @@ static void isr_txeom(struct slgt_info *info, unsigned short status)
         }
 }
 
+static void isr_gpio(struct slgt_info *info, unsigned int changed, unsigned int state)
+{
+        struct cond_wait *w, *prev;
+
+        /* wake processes waiting for specific transitions */
+        for (w = info->gpio_wait_q, prev = NULL ; w != NULL ; w = w->next) {
+                if (w->data & changed) {
+                        w->data = state;
+                        wake_up_interruptible(&w->q);
+                        if (prev != NULL)
+                                prev->next = w->next;
+                        else
+                                info->gpio_wait_q = w->next;
+                } else
+                        prev = w;
+        }
+}
+
 /* interrupt service routine
  *
  *      irq     interrupt number
@@ -2193,6 +2238,22 @@ static irqreturn_t slgt_interrupt(int irq, void *dev_id, struct pt_regs * regs)
                 }
         }
 
+        if (info->gpio_present) {
+                unsigned int state;
+                unsigned int changed;
+                while ((changed = rd_reg32(info, IOSR)) != 0) {
+                        DBGISR(("%s iosr=%08x\n", info->device_name, changed));
+                        /* read latched state of GPIO signals */
+                        state = rd_reg32(info, IOVR);
+                        /* clear pending GPIO interrupt bits */
+                        wr_reg32(info, IOSR, changed);
+                        for (i=0 ; i < info->port_count ; i++) {
+                                if (info->port_array[i] != NULL)
+                                        isr_gpio(info->port_array[i], changed, state);
+                        }
+                }
+        }
+
         for(i=0; i < info->port_count ; i++) {
                 struct slgt_info *port = info->port_array[i];
 
@@ -2276,6 +2337,8 @@ static void shutdown(struct slgt_info *info)
                 set_signals(info);
         }
 
+        flush_cond_wait(&info->gpio_wait_q);
+
         spin_unlock_irqrestore(&info->lock,flags);
 
         if (info->tty)
@@ -2650,6 +2713,175 @@ static int set_interface(struct slgt_info *info, int if_mode)
         return 0;
 }
 
+/*
+ * set general purpose IO pin state and direction
+ *
+ * user_gpio fields:
+ * state   each bit indicates a pin state
+ * smask   set bit indicates pin state to set
+ * dir     each bit indicates a pin direction (0=input, 1=output)
+ * dmask   set bit indicates pin direction to set
+ */
+static int set_gpio(struct slgt_info *info, struct gpio_desc __user *user_gpio)
+{
+        unsigned long flags;
+        struct gpio_desc gpio;
+        __u32 data;
+
+        if (!info->gpio_present)
+                return -EINVAL;
+        if (copy_from_user(&gpio, user_gpio, sizeof(gpio)))
+                return -EFAULT;
+        DBGINFO(("%s set_gpio state=%08x smask=%08x dir=%08x dmask=%08x\n",
+                 info->device_name, gpio.state, gpio.smask,
+                 gpio.dir, gpio.dmask));
+
+        spin_lock_irqsave(&info->lock,flags);
+        if (gpio.dmask) {
+                data = rd_reg32(info, IODR);
+                data |= gpio.dmask & gpio.dir;
+                data &= ~(gpio.dmask & ~gpio.dir);
+                wr_reg32(info, IODR, data);
+        }
+        if (gpio.smask) {
+                data = rd_reg32(info, IOVR);
+                data |= gpio.smask & gpio.state;
+                data &= ~(gpio.smask & ~gpio.state);
+                wr_reg32(info, IOVR, data);
+        }
+        spin_unlock_irqrestore(&info->lock,flags);
+
+        return 0;
+}
+
+/*
+ * get general purpose IO pin state and direction
+ */
+static int get_gpio(struct slgt_info *info, struct gpio_desc __user *user_gpio)
+{
+        struct gpio_desc gpio;
+        if (!info->gpio_present)
+                return -EINVAL;
+        gpio.state = rd_reg32(info, IOVR);
+        gpio.smask = 0xffffffff;
+        gpio.dir   = rd_reg32(info, IODR);
+        gpio.dmask = 0xffffffff;
+        if (copy_to_user(user_gpio, &gpio, sizeof(gpio)))
+                return -EFAULT;
+        DBGINFO(("%s get_gpio state=%08x dir=%08x\n",
+                 info->device_name, gpio.state, gpio.dir));
+        return 0;
+}
+
+/*
+ * conditional wait facility
+ */
+static void init_cond_wait(struct cond_wait *w, unsigned int data)
+{
+        init_waitqueue_head(&w->q);
+        init_waitqueue_entry(&w->wait, current);
+        w->data = data;
+}
+
+static void add_cond_wait(struct cond_wait **head, struct cond_wait *w)
+{
+        set_current_state(TASK_INTERRUPTIBLE);
+        add_wait_queue(&w->q, &w->wait);
+        w->next = *head;
+        *head = w;
+}
+
+static void remove_cond_wait(struct cond_wait **head, struct cond_wait *cw)
+{
+        struct cond_wait *w, *prev;
+        remove_wait_queue(&cw->q, &cw->wait);
+        set_current_state(TASK_RUNNING);
+        for (w = *head, prev = NULL ; w != NULL ; prev = w, w = w->next) {
+                if (w == cw) {
+                        if (prev != NULL)
+                                prev->next = w->next;
+                        else
+                                *head = w->next;
+                        break;
+                }
+        }
+}
+
+static void flush_cond_wait(struct cond_wait **head)
+{
+        while (*head != NULL) {
+                wake_up_interruptible(&(*head)->q);
+                *head = (*head)->next;
+        }
+}
+
+/*
+ * wait for general purpose I/O pin(s) to enter specified state
+ *
+ * user_gpio fields:
+ * state - bit indicates target pin state
+ * smask - set bit indicates watched pin
+ *
+ * The wait ends when at least one watched pin enters the specified
+ * state. When 0 (no error) is returned, user_gpio->state is set to the
+ * state of all GPIO pins when the wait ends.
+ *
+ * Note: Each pin may be a dedicated input, dedicated output, or
+ * configurable input/output. The number and configuration of pins
+ * varies with the specific adapter model. Only input pins (dedicated
+ * or configured) can be monitored with this function.
+ */
+static int wait_gpio(struct slgt_info *info, struct gpio_desc __user *user_gpio)
+{
+        unsigned long flags;
+        int rc = 0;
+        struct gpio_desc gpio;
+        struct cond_wait wait;
+        u32 state;
+
+        if (!info->gpio_present)
+                return -EINVAL;
+        if (copy_from_user(&gpio, user_gpio, sizeof(gpio)))
+                return -EFAULT;
+        DBGINFO(("%s wait_gpio() state=%08x smask=%08x\n",
+                 info->device_name, gpio.state, gpio.smask));
+        /* ignore output pins identified by set IODR bit */
+        if ((gpio.smask &= ~rd_reg32(info, IODR)) == 0)
+                return -EINVAL;
+        init_cond_wait(&wait, gpio.smask);
+
+        spin_lock_irqsave(&info->lock, flags);
+        /* enable interrupts for watched pins */
+        wr_reg32(info, IOER, rd_reg32(info, IOER) | gpio.smask);
+        /* get current pin states */
+        state = rd_reg32(info, IOVR);
+
+        if (gpio.smask & ~(state ^ gpio.state)) {
+                /* already in target state */
+                gpio.state = state;
+        } else {
+                /* wait for target state */
+                add_cond_wait(&info->gpio_wait_q, &wait);
+                spin_unlock_irqrestore(&info->lock, flags);
+                schedule();
+                if (signal_pending(current))
+                        rc = -ERESTARTSYS;
+                else
+                        gpio.state = wait.data;
+                spin_lock_irqsave(&info->lock, flags);
+                remove_cond_wait(&info->gpio_wait_q, &wait);
+        }
+
+        /* disable all GPIO interrupts if no waiting processes */
+        if (info->gpio_wait_q == NULL)
+                wr_reg32(info, IOER, 0);
+        spin_unlock_irqrestore(&info->lock,flags);
+
+        if ((rc == 0) && copy_to_user(user_gpio, &gpio, sizeof(gpio)))
+                rc = -EFAULT;
+        return rc;
+}
+
 static int modem_input_wait(struct slgt_info *info,int arg)
 {
         unsigned long flags;
@@ -3166,8 +3398,10 @@ static void device_init(int adapter_num, struct pci_dev *pdev)
                 } else {
                         port_array[0]->irq_requested = 1;
                         adapter_test(port_array[0]);
-                        for (i=1 ; i < port_count ; i++)
+                        for (i=1 ; i < port_count ; i++) {
                                 port_array[i]->init_error = port_array[0]->init_error;
+                                port_array[i]->gpio_present = port_array[0]->gpio_present;
+                        }
                 }
         }
 }
@@ -4301,7 +4535,7 @@ static int register_test(struct slgt_info *info)
                         break;
                 }
         }
-
+        info->gpio_present = (rd_reg32(info, JCR) & BIT5) ? 1 : 0;
         info->init_error = rc ? 0 : DiagStatus_AddressFailure;
         return rc;
 }