Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 53bcef60 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://www.jni.nu/cris 

* 'for-linus' of git://www.jni.nu/cris: (51 commits)
  CRIS: Fix alignment problem for older ld
  CRIS: Always dump registers for segfaulting process.
  CRIS: Add config for pausing a seg-faulting process
  CRIS: Don't take faults while in_atomic
  CRIS: Fixup lookup for delay slot faults
  CRIS: Discard exit.text and .data at runtime
  CRIS: Add cache aligned and read mostly data sections
  CRIS: Return something from profile write
  CRIS: Add ARTPEC-3 and timestamps for sync-serial
  CRIS: Better ARTPEC-3 support for gpio
  CRIS: Add include guard
  CRIS: Better handling of pinmux settings
  CRIS: New DMA defines for ARTPEC-3
  CRIS: __do_strncpy_from_user: Don't read the byte beyond the nil
  CRIS: Pagetable for ARTPEC-3
  CRIS: Machine dependent memmap.h
  CRIS: Check if pointer is set before using it
  CRIS: Machine dependent dma.h
  CRIS: Define __read_mostly for CRISv32
  CRIS: Discard .note.gnu.build-id section
  ...
parents 4fd6c6bf 85d98657

arch/cris/Kconfig

+4 −1
Original line number Diff line number Diff line
@@ -24,7 +24,7 @@ config GENERIC_CMOS_UPDATE 
	def_bool y



config ARCH_USES_GETTIMEOFFSET

	def_bool y

	def_bool n



config GENERIC_IOMAP

       bool
@@ -128,16 +128,19 @@ choice 


config ETRAX100LX

	bool "ETRAX-100LX-v1"

	select ARCH_USES_GETTIMEOFFSET

	help

	  Support version 1 of the ETRAX 100LX.



config ETRAX100LX_V2

	bool "ETRAX-100LX-v2"

	select ARCH_USES_GETTIMEOFFSET

	help

	  Support version 2 of the ETRAX 100LX.



config SVINTO_SIM

	bool "ETRAX-100LX-for-xsim-simulator"

	select ARCH_USES_GETTIMEOFFSET

	help

	  Support the xsim ETRAX Simulator.

arch/cris/Kconfig.debug

+6 −0
Original line number Diff line number Diff line
@@ -32,4 +32,10 @@ config DEBUG_NMI_OOPS 
	  If the system locks up without any debug information you can say Y

	  here to make it possible to dump an OOPS with an external NMI.



config NO_SEGFAULT_TERMINATION

	bool "Keep segfaulting processes"

	help

	  Place segfaulting user mode processes on a wait queue instead of

	  delivering a terminating SIGSEGV to allow debugging with gdb.



endmenu

arch/cris/arch-v10/drivers/Kconfig

+1 −1
Original line number Diff line number Diff line
@@ -383,7 +383,7 @@ config ETRAX_RS485 
	depends on ETRAX_SERIAL

	help

	  Enables support for RS-485 serial communication.  For a primer on

	  RS-485, see <http://www.hw.cz/english/docs/rs485/rs485.html>.

	  RS-485, see <http://en.wikipedia.org/wiki/Rs485>



config ETRAX_RS485_ON_PA

	bool "RS-485 mode on PA"

arch/cris/arch-v10/drivers/eeprom.c

+0 −2
Original line number Diff line number Diff line
@@ -28,7 +28,6 @@ 
#include <linux/init.h>

#include <linux/delay.h>

#include <linux/interrupt.h>

#include <linux/smp_lock.h>

#include <linux/wait.h>

#include <asm/uaccess.h>

#include "i2c.h"
@@ -376,7 +375,6 @@ int __init eeprom_init(void) 
/* Opens the device. */

static int eeprom_open(struct inode * inode, struct file * file)

{

  cycle_kernel_lock();

  if(iminor(inode) != EEPROM_MINOR_NR)

     return -ENXIO;

  if(imajor(inode) != EEPROM_MAJOR_NR)

arch/cris/arch-v10/drivers/gpio.c

+54 −28
Original line number Diff line number Diff line
@@ -16,7 +16,6 @@ 
#include <linux/errno.h>

#include <linux/kernel.h>

#include <linux/fs.h>

#include <linux/smp_lock.h>

#include <linux/string.h>

#include <linux/poll.h>

#include <linux/init.h>
@@ -46,8 +45,7 @@ static char gpio_name[] = "etrax gpio"; 
static wait_queue_head_t *gpio_wq;

#endif



static int gpio_ioctl(struct inode *inode, struct file *file,

	unsigned int cmd, unsigned long arg);

static long gpio_ioctl(struct file *file, unsigned int cmd, unsigned long arg);

static ssize_t gpio_write(struct file *file, const char __user *buf,

	size_t count, loff_t *off);

static int gpio_open(struct inode *inode, struct file *filp);
@@ -324,7 +322,6 @@ gpio_open(struct inode *inode, struct file *filp) 
	if (!priv)

		return -ENOMEM;



	lock_kernel();

	priv->minor = p;



	/* initialize the io/alarm struct */
@@ -359,7 +356,6 @@ gpio_open(struct inode *inode, struct file *filp) 
	alarmlist = priv;

	spin_unlock_irqrestore(&gpio_lock, flags);



	unlock_kernel();

	return 0;

}
@@ -504,9 +500,7 @@ unsigned long inline setget_output(struct gpio_private *priv, unsigned long arg) 
static int

gpio_leds_ioctl(unsigned int cmd, unsigned long arg);



static int

gpio_ioctl(struct inode *inode, struct file *file,

	   unsigned int cmd, unsigned long arg)

static long gpio_ioctl(struct file *file, unsigned int cmd, unsigned long arg)

{

	unsigned long flags;

	unsigned long val;
@@ -516,54 +510,65 @@ gpio_ioctl(struct inode *inode, struct file *file, 
	if (_IOC_TYPE(cmd) != ETRAXGPIO_IOCTYPE)

		return -EINVAL;



	spin_lock_irqsave(&gpio_lock, flags);



	switch (_IOC_NR(cmd)) {

	case IO_READBITS: /* Use IO_READ_INBITS and IO_READ_OUTBITS instead */

		// read the port

		spin_lock_irqsave(&gpio_lock, flags);

		if (USE_PORTS(priv)) {

			ret =  *priv->port;

		} else if (priv->minor == GPIO_MINOR_G) {

			ret =  (*R_PORT_G_DATA) & 0x7FFFFFFF;

		}

		spin_unlock_irqrestore(&gpio_lock, flags);



		break;

	case IO_SETBITS:

		// set changeable bits with a 1 in arg

		spin_lock_irqsave(&gpio_lock, flags);



		if (USE_PORTS(priv)) {

			*priv->port = *priv->shadow |=

			  ((unsigned char)arg & priv->changeable_bits);

		} else if (priv->minor == GPIO_MINOR_G) {

			*R_PORT_G_DATA = port_g_data_shadow |= (arg & dir_g_out_bits);

		}

		spin_unlock_irqrestore(&gpio_lock, flags);



		break;

	case IO_CLRBITS:

		// clear changeable bits with a 1 in arg

		spin_lock_irqsave(&gpio_lock, flags);

		if (USE_PORTS(priv)) {

			*priv->port = *priv->shadow &=

			 ~((unsigned char)arg & priv->changeable_bits);

		} else if (priv->minor == GPIO_MINOR_G) {

			*R_PORT_G_DATA = port_g_data_shadow &= ~((unsigned long)arg & dir_g_out_bits);

		}

		spin_unlock_irqrestore(&gpio_lock, flags);

		break;

	case IO_HIGHALARM:

		// set alarm when bits with 1 in arg go high

		spin_lock_irqsave(&gpio_lock, flags);

		priv->highalarm |= arg;

		gpio_some_alarms = 1;

		spin_unlock_irqrestore(&gpio_lock, flags);

		break;

	case IO_LOWALARM:

		// set alarm when bits with 1 in arg go low

		spin_lock_irqsave(&gpio_lock, flags);

		priv->lowalarm |= arg;

		gpio_some_alarms = 1;

		spin_unlock_irqrestore(&gpio_lock, flags);

		break;

	case IO_CLRALARM:

		// clear alarm for bits with 1 in arg

		/* clear alarm for bits with 1 in arg */

		spin_lock_irqsave(&gpio_lock, flags);

		priv->highalarm &= ~arg;

		priv->lowalarm  &= ~arg;

		{

			/* Must update gpio_some_alarms */

			struct gpio_private *p = alarmlist;

			int some_alarms;

			spin_lock_irq(&gpio_lock);

			p = alarmlist;

			some_alarms = 0;

			while (p) {
@@ -574,11 +579,12 @@ gpio_ioctl(struct inode *inode, struct file *file, 
				p = p->next;

			}

			gpio_some_alarms = some_alarms;

			spin_unlock_irq(&gpio_lock);

		}

		spin_unlock_irqrestore(&gpio_lock, flags);

		break;

	case IO_READDIR: /* Use IO_SETGET_INPUT/OUTPUT instead! */

		/* Read direction 0=input 1=output */

		spin_lock_irqsave(&gpio_lock, flags);

		if (USE_PORTS(priv)) {

			ret = *priv->dir_shadow;

		} else if (priv->minor == GPIO_MINOR_G) {
@@ -587,30 +593,40 @@ gpio_ioctl(struct inode *inode, struct file *file, 
			 */

			ret = (dir_g_shadow | dir_g_out_bits) & 0x7FFFFFFF;

		}

		spin_unlock_irqrestore(&gpio_lock, flags);

		break;

	case IO_SETINPUT: /* Use IO_SETGET_INPUT instead! */

		/* Set direction 0=unchanged 1=input,

		 * return mask with 1=input

		 */

		spin_lock_irqsave(&gpio_lock, flags);

		ret = setget_input(priv, arg) & 0x7FFFFFFF;

		spin_unlock_irqrestore(&gpio_lock, flags);

		break;

	case IO_SETOUTPUT: /* Use IO_SETGET_OUTPUT instead! */

		/* Set direction 0=unchanged 1=output,

		 * return mask with 1=output

		 */

		spin_lock_irqsave(&gpio_lock, flags);

		ret =  setget_output(priv, arg) & 0x7FFFFFFF;

		spin_unlock_irqrestore(&gpio_lock, flags);

		break;

	case IO_SHUTDOWN:

		spin_lock_irqsave(&gpio_lock, flags);

		SOFT_SHUTDOWN();

		spin_unlock_irqrestore(&gpio_lock, flags);

		break;

	case IO_GET_PWR_BT:

		spin_lock_irqsave(&gpio_lock, flags);

#if defined (CONFIG_ETRAX_SOFT_SHUTDOWN)

		ret = (*R_PORT_G_DATA & ( 1 << CONFIG_ETRAX_POWERBUTTON_BIT));

#else

		ret = 0;

#endif

		spin_unlock_irqrestore(&gpio_lock, flags);

		break;

	case IO_CFG_WRITE_MODE:

		spin_lock_irqsave(&gpio_lock, flags);

		priv->clk_mask = arg & 0xFF;

		priv->data_mask = (arg >> 8) & 0xFF;

		priv->write_msb = (arg >> 16) & 0x01;
@@ -626,24 +642,29 @@ gpio_ioctl(struct inode *inode, struct file *file, 
			priv->data_mask = 0;

			ret = -EPERM;

		}

		spin_unlock_irqrestore(&gpio_lock, flags);

		break;

	case IO_READ_INBITS:

		/* *arg is result of reading the input pins */

		spin_lock_irqsave(&gpio_lock, flags);

		if (USE_PORTS(priv)) {

			val = *priv->port;

		} else if (priv->minor == GPIO_MINOR_G) {

			val = *R_PORT_G_DATA;

		}

		spin_unlock_irqrestore(&gpio_lock, flags);

		if (copy_to_user((void __user *)arg, &val, sizeof(val)))

			ret = -EFAULT;

		break;

	case IO_READ_OUTBITS:

		 /* *arg is result of reading the output shadow */

		spin_lock_irqsave(&gpio_lock, flags);

		if (USE_PORTS(priv)) {

			val = *priv->shadow;

		} else if (priv->minor == GPIO_MINOR_G) {

			val = port_g_data_shadow;

		}

		spin_unlock_irqrestore(&gpio_lock, flags);

		if (copy_to_user((void __user *)arg, &val, sizeof(val)))

			ret = -EFAULT;

		break;
@@ -656,7 +677,9 @@ gpio_ioctl(struct inode *inode, struct file *file, 
			ret = -EFAULT;

			break;

		}

		spin_lock_irqsave(&gpio_lock, flags);

		val = setget_input(priv, val);

		spin_unlock_irqrestore(&gpio_lock, flags);

		if (copy_to_user((void __user *)arg, &val, sizeof(val)))

			ret = -EFAULT;

		break;
@@ -668,18 +691,21 @@ gpio_ioctl(struct inode *inode, struct file *file, 
			ret = -EFAULT;

			break;

		}

		spin_lock_irqsave(&gpio_lock, flags);

		val = setget_output(priv, val);

		spin_unlock_irqrestore(&gpio_lock, flags);

		if (copy_to_user((void __user *)arg, &val, sizeof(val)))

			ret = -EFAULT;

		break;

	default:

		spin_lock_irqsave(&gpio_lock, flags);

		if (priv->minor == GPIO_MINOR_LEDS)

			ret = gpio_leds_ioctl(cmd, arg);

		else

			ret = -EINVAL;

		spin_unlock_irqrestore(&gpio_lock, flags);

	} /* switch */



	spin_unlock_irqrestore(&gpio_lock, flags);

	return ret;

}
@@ -715,7 +741,7 @@ gpio_leds_ioctl(unsigned int cmd, unsigned long arg) 
static const struct file_operations gpio_fops = {

	.owner          = THIS_MODULE,

	.poll           = gpio_poll,

	.ioctl       = gpio_ioctl,

	.unlocked_ioctl = gpio_ioctl,

	.write          = gpio_write,

	.open           = gpio_open,

	.release        = gpio_release,