[Armadeus-commitlog] SF.net SVN: armadeus: [697] trunk/buildroot/target/device/armadeus/linux/ kern
Brought to you by:
sszy
Menu
▾
▴
[Armadeus-commitlog] SF.net SVN: armadeus: [697] trunk/buildroot/target/device/armadeus/linux/ kernel-patches/2.6.23.1
|
From: <th...@us...> - 2007-11-17 22:12:03
|
Revision: 697
http://armadeus.svn.sourceforge.net/armadeus/?rev=697&view=rev
Author: thom25
Date: 2007-11-17 14:12:02 -0800 (Sat, 17 Nov 2007)
Log Message:
-----------
add MCP2515 to APF9328
fix indentation in MCP2515 + bug in SPI_MODE
Modified Paths:
--------------
trunk/buildroot/target/device/armadeus/linux/kernel-patches/2.6.23.1/021-linux-2.6.23.1-apf9328.diff
trunk/buildroot/target/device/armadeus/linux/kernel-patches/2.6.23.1/088-mcp2515.diff
Modified: trunk/buildroot/target/device/armadeus/linux/kernel-patches/2.6.23.1/021-linux-2.6.23.1-apf9328.diff
===================================================================
--- trunk/buildroot/target/device/armadeus/linux/kernel-patches/2.6.23.1/021-linux-2.6.23.1-apf9328.diff 2007-11-17 22:01:36 UTC (rev 696)
+++ trunk/buildroot/target/device/armadeus/linux/kernel-patches/2.6.23.1/021-linux-2.6.23.1-apf9328.diff 2007-11-17 22:12:02 UTC (rev 697)
@@ -808,7 +808,7 @@
+CONFIG_ZLIB_DEFLATE=y
--- linux-2.6.23.1.1/arch/arm/mach-imx/apf9328.c 1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.23.1.1.mod/arch/arm/mach-imx/apf9328.c 2007-07-22 22:46:57.000000000 +0200
-@@ -0,0 +1,464 @@
+@@ -0,0 +1,527 @@
+/*
+ * linux/arch/arm/mach-imx/apf9328.c
+ *
@@ -836,6 +836,7 @@
+#include <linux/serial_8250.h>
+#include <linux/spi/spi.h>
+#include <linux/spi/tsc2102.h>
++#include "../../../drivers/net/can/mcp251x.h"
+
+#include <asm/system.h>
+#include <asm/hardware.h>
@@ -866,6 +867,9 @@
+#ifdef CONFIG_SPI_TSC2102_MODULE
+#define CONFIG_SPI_TSC2102 1
+#endif
++#ifdef CONFIG_CAN_MCP251X_MODULE
++#define CONFIG_CAN_MCP251X 1
++#endif
+#ifdef CONFIG_IMX_BACKLIGHT_MODULE
+#define CONFIG_IMX_BACKLIGHT 1
+#endif
@@ -1129,6 +1133,47 @@
+
+#endif // CONFIG_SPI_TSC2102
+
++#ifdef CONFIG_CAN_MCP251X
++#define CAN_MPC251X_CS_GPIOB 19
++
++// Chip select command for MCP251X
++static void mcp251X_cs(u32 command)
++{
++ // PortB 19 is used as chip select
++ if( command == SPI_CS_DEASSERT )
++ DR(1) |= 1<< CAN_MPC251X_CS_GPIOB;
++ else
++ DR(1) &= ~(1<< CAN_MPC251X_CS_GPIOB);
++}
++
++static struct spi_imx_chip mcp251X_hw = {
++ .cs_control = mcp251X_cs,
++};
++
++static void mcp251X_init_gpio(void)
++{
++ // Activate SPI2 port ----
++ // PortB 19 is used as chip select (in GPIO mode)
++ DR(1) |= 1 << CAN_MPC251X_CS_GPIOB; // Initializes it High
++ imx_gpio_mode( GPIO_PORTB | CAN_MPC251X_CS_GPIOB | GPIO_OUT | GPIO_GIUS | GPIO_DR );
++ // Configure SPI2 outputs
++ imx_gpio_mode( PD7_AIN_SPI2_SCLK );
++ imx_gpio_mode( PD10_AIN_SPI2_TXD );
++ imx_gpio_mode( PD9_AOUT_SPI2_RXD );
++ FMCR |= SPI2_RXD_SEL; // RX is AOUT on PORTD
++ imx_gpio_mode( GPIO_PORTC | 13 | GPIO_IN | GPIO_GIUS );
++}
++
++static struct mcp251x_platform_data apf9328_mcp251x_config = {
++ .oscillator_frequency = 16000000,
++ .board_specific_setup = NULL,
++ .device_reset = NULL,
++ .transceiver_enable = NULL,
++};
++
++#endif
++
++
+static struct spi_board_info spi_board_info[] __initdata = {
+#ifdef CONFIG_SENSORS_MAX1027
+{
@@ -1152,6 +1197,18 @@
+ .platform_data = &apf9328_tsc2102_config,
+},
+#endif // CONFIG_SPI_TSC2102
++#ifdef CONFIG_CAN_MCP251X
++ {
++ .modalias = "mcp251x",
++ .max_speed_hz = 8000000, /* 8MHz */
++ .controller_data = &mcp251X_hw,
++ .bus_num = 2,
++ .mode = SPI_MODE_0,
++ .chip_select = 0,
++ .irq = IRQ_GPIOC(13),
++ .platform_data = &apf9328_mcp251x_config,
++ },
++#endif // CONFIG_CAN_MCP251X
+};
+
+// --- LCD RESSOURCE ---
@@ -1216,11 +1273,14 @@
+#ifdef CONFIG_SPI_TSC2102
+ tsc2102_init_gpio();
+#endif // CONFIG_SPI_TSC2102
++#ifdef CONFIG_CAN_MCP251X
++ mcp251X_init_gpio();
++#endif // CONFIG_CAN_MCP251X
+
+ platform_add_devices(devices, ARRAY_SIZE(devices));
-+#if defined (CONFIG_SENSORS_MAX1027) || defined (CONFIG_SPI_TSC2102)
++#if defined (CONFIG_SENSORS_MAX1027) || defined (CONFIG_SPI_TSC2102) || defined (CONFIG_CAN_MCP251X)
+ spi_register_board_info(spi_board_info, ARRAY_SIZE(spi_board_info));
-+#endif // CONFIG_SENSORS_MAX1027
++#endif
+
+ printk("--- APF9328 ressources registered\n");
+}
@@ -1260,6 +1320,9 @@
+#ifdef CONFIG_SPI_TSC2102
+ set_irq_type( IRQ_GPIOD(8), IRQF_TRIGGER_FALLING );
+#endif // CONFIG_SPI_TSC2102
++#ifdef CONFIG_CAN_MCP251X
++ set_irq_type( IRQ_GPIOC(13), IRQF_TRIGGER_FALLING );
++#endif // CONFIG_CAN_MCP251X
+}
+
+
Modified: trunk/buildroot/target/device/armadeus/linux/kernel-patches/2.6.23.1/088-mcp2515.diff
===================================================================
--- trunk/buildroot/target/device/armadeus/linux/kernel-patches/2.6.23.1/088-mcp2515.diff 2007-11-17 22:01:36 UTC (rev 696)
+++ trunk/buildroot/target/device/armadeus/linux/kernel-patches/2.6.23.1/088-mcp2515.diff 2007-11-17 22:12:02 UTC (rev 697)
@@ -31,7 +31,7 @@
===================================================================
--- /dev/null
+++ linux-2.6.19.2/drivers/net/can/mcp251x.c
-@@ -0,0 +1,972 @@
+@@ -0,0 +1,964 @@
+/*
+ * Copyright 2007 Raymarine UK, Ltd. All Rights Reserved.
+ * Written under contract by Katalix Systems, Ltd.
@@ -98,51 +98,51 @@
+/* MPC251x registers */
+#define CANSTAT 0x0e
+#define CANCTRL 0x0f
-+# define CANCTRL_REQOP_MASK 0xe0
-+# define CANCTRL_REQOP_CONF 0x80
-+# define CANCTRL_REQOP_LISTEN_ONLY 0x60
-+# define CANCTRL_REQOP_LOOPBACK 0x40
-+# define CANCTRL_REQOP_SLEEP 0x20
-+# define CANCTRL_REQOP_NORMAL 0x00
-+# define CANCTRL_OSM 0x08
++#define CANCTRL_REQOP_MASK 0xe0
++#define CANCTRL_REQOP_CONF 0x80
++#define CANCTRL_REQOP_LISTEN_ONLY 0x60
++#define CANCTRL_REQOP_LOOPBACK 0x40
++#define CANCTRL_REQOP_SLEEP 0x20
++#define CANCTRL_REQOP_NORMAL 0x00
++#define CANCTRL_OSM 0x08
+#define TEC 0x1c
+#define REC 0x1d
+#define CNF1 0x2a
+#define CNF2 0x29
-+# define CNF2_BTLMODE 0x80
++#define CNF2_BTLMODE 0x80
+#define CNF3 0x28
-+# define CNF3_SOF 0x08
-+# define CNF3_WAKFIL 0x04
-+# define CNF3_PHSEG2_MASK 0x07
++#define CNF3_SOF 0x08
++#define CNF3_WAKFIL 0x04
++#define CNF3_PHSEG2_MASK 0x07
+#define CANINTE 0x2b
-+# define CANINTE_MERRE 0x80
-+# define CANINTE_WAKIE 0x40
-+# define CANINTE_ERRIE 0x20
-+# define CANINTE_TX2IE 0x10
-+# define CANINTE_TX1IE 0x08
-+# define CANINTE_TX0IE 0x04
-+# define CANINTE_RX1IE 0x02
-+# define CANINTE_RX0IE 0x01
++#define CANINTE_MERRE 0x80
++#define CANINTE_WAKIE 0x40
++#define CANINTE_ERRIE 0x20
++#define CANINTE_TX2IE 0x10
++#define CANINTE_TX1IE 0x08
++#define CANINTE_TX0IE 0x04
++#define CANINTE_RX1IE 0x02
++#define CANINTE_RX0IE 0x01
+#define CANINTF 0x2c
-+# define CANINTF_MERRF 0x80
-+# define CANINTF_WAKIF 0x40
-+# define CANINTF_ERRIF 0x20
-+# define CANINTF_TX2IF 0x10
-+# define CANINTF_TX1IF 0x08
-+# define CANINTF_TX0IF 0x04
-+# define CANINTF_RX1IF 0x02
-+# define CANINTF_RX0IF 0x01
++#define CANINTF_MERRF 0x80
++#define CANINTF_WAKIF 0x40
++#define CANINTF_ERRIF 0x20
++#define CANINTF_TX2IF 0x10
++#define CANINTF_TX1IF 0x08
++#define CANINTF_TX0IF 0x04
++#define CANINTF_RX1IF 0x02
++#define CANINTF_RX0IF 0x01
+#define EFLG 0x2d
-+# define EFLG_EWARN 0x01
-+# define EFLG_RXWAR 0x02
-+# define EFLG_TXWAR 0x04
-+# define EFLG_RXEP 0x08
-+# define EFLG_TXEP 0x10
-+# define EFLG_TXBO 0x20
-+# define EFLG_RX0OVR 0x40
-+# define EFLG_RX1OVR 0x80
++#define EFLG_EWARN 0x01
++#define EFLG_RXWAR 0x02
++#define EFLG_TXWAR 0x04
++#define EFLG_RXEP 0x08
++#define EFLG_TXEP 0x10
++#define EFLG_TXBO 0x20
++#define EFLG_RX0OVR 0x40
++#define EFLG_RX1OVR 0x80
+#define TXBCTRL(n) ((n * 0x10) + 0x30)
-+# define TXBCTRL_TXREQ 0x08
++#define TXBCTRL_TXREQ 0x08
+
+/* Buffer size required for the largest SPI transfer (i.e., reading a
+ * frame). */
@@ -160,599 +160,592 @@
+MODULE_PARM_DESC(loopback, "Loop back frames (for testing). Default: 0 (Off)");
+
+struct mcp251x_priv {
-+ struct can_priv can;
-+ struct net_device *net;
-+ struct spi_device *spi;
++ struct can_priv can;
++ struct net_device *net;
++ struct spi_device *spi;
+
-+ struct semaphore spi_lock; /* SPI buffer lock */
-+ uint8_t *spi_tx_buf;
-+ uint8_t *spi_rx_buf;
-+ dma_addr_t spi_tx_dma;
-+ dma_addr_t spi_rx_dma;
++ struct semaphore spi_lock; /* SPI buffer lock */
++ uint8_t *spi_tx_buf;
++ uint8_t *spi_rx_buf;
++ dma_addr_t spi_tx_dma;
++ dma_addr_t spi_rx_dma;
+
-+ struct sk_buff *tx_skb;
-+ struct work_struct tx_work;
-+ struct work_struct irq_work;
++ struct sk_buff *tx_skb;
++ struct work_struct tx_work;
++ struct work_struct irq_work;
+};
+
+
+static uint8_t mcp251x_read_reg(struct spi_device *spi, uint8_t reg)
+{
-+ struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);
-+ struct spi_transfer t = {
-+ .tx_buf = priv->spi_tx_buf,
-+ .rx_buf = priv->spi_rx_buf,
-+ .len = 3,
-+ .cs_change = 0,
-+ };
-+ struct spi_message m;
-+ uint8_t val = 0;
-+ int ret;
++ struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);
++ struct spi_transfer t = {
++ .tx_buf = priv->spi_tx_buf,
++ .rx_buf = priv->spi_rx_buf,
++ .len = 3,
++ .cs_change = 0,
++ };
++ struct spi_message m;
++ uint8_t val = 0;
++ int ret;
+
-+ down(&priv->spi_lock);
++ down(&priv->spi_lock);
+
-+ priv->spi_tx_buf[0] = INSTRUCTION_READ;
-+ priv->spi_tx_buf[1] = reg;
++ priv->spi_tx_buf[0] = INSTRUCTION_READ;
++ priv->spi_tx_buf[1] = reg;
+
-+ spi_message_init(&m);
++ spi_message_init(&m);
+
-+ if (enable_dma) {
-+ t.tx_dma = priv->spi_tx_dma;
-+ t.rx_dma = priv->spi_rx_dma;
-+ m.is_dma_mapped = 1;
-+ }
++ if (enable_dma) {
++ t.tx_dma = priv->spi_tx_dma;
++ t.rx_dma = priv->spi_rx_dma;
++ m.is_dma_mapped = 1;
++ }
+
-+ spi_message_add_tail(&t, &m);
++ spi_message_add_tail(&t, &m);
+
-+ ret = spi_sync(spi, &m);
-+ if (ret < 0) {
-+ dev_dbg(&spi->dev, "%s: failed: ret = %d\n", __FUNCTION__, ret);
-+ } else
-+ val = priv->spi_rx_buf[2];
++ ret = spi_sync(spi, &m);
++ if (ret < 0) {
++ dev_dbg(&spi->dev, "%s: failed: ret = %d\n", __FUNCTION__, ret);
++ } else
++ val = priv->spi_rx_buf[2];
+
-+ up(&priv->spi_lock);
++ up(&priv->spi_lock);
+
-+ /*dev_dbg(&spi->dev, "%s: reg 0x%02X val 0x%02X\n", __FUNCTION__, reg, val);*/
++ /*dev_dbg(&spi->dev, "%s: reg 0x%02X val 0x%02X\n", __FUNCTION__, reg, val);*/
+
-+ return val;
++ return val;
+}
+
+
+static void mcp251x_write_reg(struct spi_device *spi, uint8_t reg, uint8_t val)
+{
-+ struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);
-+ struct spi_transfer t = {
-+ .tx_buf = priv->spi_tx_buf,
-+ .rx_buf = priv->spi_rx_buf,
-+ .len = 3,
-+ .cs_change = 0,
-+ };
-+ struct spi_message m;
-+ int ret;
++ struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);
++ struct spi_transfer t = {
++ .tx_buf = priv->spi_tx_buf,
++ .rx_buf = priv->spi_rx_buf,
++ .len = 3,
++ .cs_change = 0,
++ };
++ struct spi_message m;
++ int ret;
+
-+ /*dev_dbg(&spi->dev, "%s: reg 0x%02X val 0x%02X\n", __FUNCTION__, reg, val);*/
++ /*dev_dbg(&spi->dev, "%s: reg 0x%02X val 0x%02X\n", __FUNCTION__, reg, val);*/
+
-+ down(&priv->spi_lock);
++ down(&priv->spi_lock);
+
-+ priv->spi_tx_buf[0] = INSTRUCTION_WRITE;
-+ priv->spi_tx_buf[1] = reg;
-+ priv->spi_tx_buf[2] = val;
++ priv->spi_tx_buf[0] = INSTRUCTION_WRITE;
++ priv->spi_tx_buf[1] = reg;
++ priv->spi_tx_buf[2] = val;
+
-+ spi_message_init(&m);
++ spi_message_init(&m);
+
-+ if (enable_dma) {
-+ t.tx_dma = priv->spi_tx_dma;
-+ t.rx_dma = priv->spi_rx_dma;
-+ m.is_dma_mapped = 1;
-+ }
++ if (enable_dma) {
++ t.tx_dma = priv->spi_tx_dma;
++ t.rx_dma = priv->spi_rx_dma;
++ m.is_dma_mapped = 1;
++ }
+
-+ spi_message_add_tail(&t, &m);
++ spi_message_add_tail(&t, &m);
+
-+ ret = spi_sync(spi, &m);
++ ret = spi_sync(spi, &m);
+
-+ up(&priv->spi_lock);
++ up(&priv->spi_lock);
+
-+ if (ret < 0)
-+ dev_dbg(&spi->dev, "%s: failed\n", __FUNCTION__);
++ if (ret < 0)
++ dev_dbg(&spi->dev, "%s: failed\n", __FUNCTION__);
+
-+ return;
++ return;
+}
+
+
+static void mcp251x_write_bits(struct spi_device *spi, uint8_t reg,
+ uint8_t mask, uint8_t val)
+{
-+ struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);
-+ struct spi_transfer t = {
-+ .tx_buf = priv->spi_tx_buf,
-+ .rx_buf = priv->spi_rx_buf,
-+ .len = 4,
-+ .cs_change = 0,
-+ };
-+ struct spi_message m;
-+ int ret;
++ struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);
++ struct spi_transfer t = {
++ .tx_buf = priv->spi_tx_buf,
++ .rx_buf = priv->spi_rx_buf,
++ .len = 4,
++ .cs_change = 0,
++ };
++ struct spi_message m;
++ int ret;
+
-+ down(&priv->spi_lock);
++ down(&priv->spi_lock);
+
-+ priv->spi_tx_buf[0] = INSTRUCTION_BIT_MODIFY;
-+ priv->spi_tx_buf[1] = reg;
-+ priv->spi_tx_buf[2] = mask;
-+ priv->spi_tx_buf[3] = val;
++ priv->spi_tx_buf[0] = INSTRUCTION_BIT_MODIFY;
++ priv->spi_tx_buf[1] = reg;
++ priv->spi_tx_buf[2] = mask;
++ priv->spi_tx_buf[3] = val;
+
-+ spi_message_init(&m);
++ spi_message_init(&m);
+
-+ if (enable_dma) {
-+ t.tx_dma = priv->spi_tx_dma;
-+ t.rx_dma = priv->spi_rx_dma;
-+ m.is_dma_mapped = 1;
-+ }
++ if (enable_dma) {
++ t.tx_dma = priv->spi_tx_dma;
++ t.rx_dma = priv->spi_rx_dma;
++ m.is_dma_mapped = 1;
++ }
+
-+ spi_message_add_tail(&t, &m);
++ spi_message_add_tail(&t, &m);
+
-+ ret = spi_sync(spi, &m);
-+ if (ret < 0)
-+ dev_dbg(&spi->dev, "%s: failed\n", __FUNCTION__);
++ ret = spi_sync(spi, &m);
++ if (ret < 0)
++ dev_dbg(&spi->dev, "%s: failed\n", __FUNCTION__);
+
-+ up(&priv->spi_lock);
++ up(&priv->spi_lock);
+
-+ return;
++ return;
+}
+
+
+static void mcp251x_hw_tx(struct spi_device *spi, struct can_frame *frame,
-+int tx_buf_idx)
++ int tx_buf_idx)
+{
-+ struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);
-+ struct spi_transfer t = {
-+ .tx_buf = priv->spi_tx_buf,
-+ .rx_buf = priv->spi_rx_buf,
-+ .cs_change = 0,
-+ .len = 6 + CAN_FRAME_MAX_DATA_LEN,
-+ };
-+ uint8_t *tx_buf = priv->spi_tx_buf;
-+ struct spi_message m;
-+ int ret;
-+ uint32_t sid, eid, exide, rtr;
++ struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);
++ struct spi_transfer t = {
++ .tx_buf = priv->spi_tx_buf,
++ .rx_buf = priv->spi_rx_buf,
++ .cs_change = 0,
++ .len = 6 + CAN_FRAME_MAX_DATA_LEN,
++ };
++ uint8_t *tx_buf = priv->spi_tx_buf;
++ struct spi_message m;
++ int ret;
++ uint32_t sid, eid, exide, rtr;
+
-+ int i;
++ dev_dbg(&spi->dev, "%s\n", __FUNCTION__);
+
-+ dev_dbg(&spi->dev, "%s\n", __FUNCTION__);
++ sid = frame->can_id & CAN_SFF_MASK; /* Standard ID */
++ eid = frame->can_id & CAN_EFF_MASK; /* Extended ID */
++ exide = (frame->can_id & CAN_EFF_FLAG) ? 1 : 0; /* Extended ID Enable */
++ rtr = (frame->can_id & CAN_RTR_FLAG) ? 1 : 0; /* Remote transmission */
+
-+ sid = frame->can_id & CAN_SFF_MASK; /* Standard ID */
-+ eid = frame->can_id & CAN_EFF_MASK; /* Extended ID */
-+ exide = (frame->can_id & CAN_EFF_FLAG) ? 1 : 0; /* Extended ID Enable */
-+ rtr = (frame->can_id & CAN_RTR_FLAG) ? 1 : 0; /* Remote transmission */
++ mcp251x_read_reg(spi, CANSTAT);
+
-+ mcp251x_read_reg(spi, CANSTAT);
++ down(&priv->spi_lock);
+
-+ down(&priv->spi_lock);
++ tx_buf[0] = INSTRUCTION_LOAD_TXB(tx_buf_idx);
++ tx_buf[1] = sid >> 3;
++ tx_buf[2] = (sid << 5) | (exide << 3) | (eid >> 16);
++ tx_buf[3] = eid >> 8;
++ tx_buf[4] = eid;
++ tx_buf[5] = (rtr << 6) | frame->can_dlc;
+
-+ tx_buf[0] = INSTRUCTION_LOAD_TXB(tx_buf_idx);
-+ tx_buf[1] = sid >> 3;
-+ tx_buf[2] = (sid << 5) | (exide << 3) | (eid >> 16);
-+ tx_buf[3] = eid >> 8;
-+ tx_buf[4] = eid;
-+ tx_buf[5] = (rtr << 6) | frame->can_dlc;
++ memcpy(tx_buf + 6, frame->data, frame->can_dlc);
+
-+ memcpy(tx_buf + 6, frame->data, frame->can_dlc);
++ spi_message_init(&m);
+
-+ spi_message_init(&m);
++ if (enable_dma) {
++ t.tx_dma = priv->spi_tx_dma;
++ t.rx_dma = priv->spi_rx_dma;
++ m.is_dma_mapped = 1;
++ }
+
-+ if (enable_dma) {
-+ t.tx_dma = priv->spi_tx_dma;
-+ t.rx_dma = priv->spi_rx_dma;
-+ m.is_dma_mapped = 1;
-+ }
++ spi_message_add_tail(&t, &m);
+
-+ spi_message_add_tail(&t, &m);
++ ret = spi_sync(spi, &m);
++ if (ret < 0)
++ dev_dbg(&spi->dev, "%s: failed: ret = %d\n", __FUNCTION__, ret);
+
-+ ret = spi_sync(spi, &m);
-+ if (ret < 0)
-+ dev_dbg(&spi->dev, "%s: failed: ret = %d\n", __FUNCTION__, ret);
++ /* FIXME: Should we exit with an error here? */
+
-+ /* FIXME: Should we exit with an error here? */
++ up(&priv->spi_lock);
+
-+ up(&priv->spi_lock);
++ mcp251x_write_reg(spi, TXBCTRL(tx_buf_idx), TXBCTRL_TXREQ);
+
-+ mcp251x_write_reg(spi, TXBCTRL(tx_buf_idx), TXBCTRL_TXREQ);
-+
-+ return;
++ return;
+}
+
+
+static void mcp251x_hw_rx(struct spi_device *spi, int buf_idx)
+{
-+ struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);
-+ struct spi_transfer t = {
-+ .tx_buf = priv->spi_tx_buf,
-+ .rx_buf = priv->spi_rx_buf,
-+ .cs_change = 0,
-+ .len = 14,
-+ };
-+ uint8_t *tx_buf = priv->spi_tx_buf;
-+ uint8_t *rx_buf = priv->spi_rx_buf;
-+ struct spi_message m;
-+ struct sk_buff *skb;
-+ struct can_frame *frame;
-+ int ret;
-+ int i;
++ struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);
++ struct spi_transfer t = {
++ .tx_buf = priv->spi_tx_buf,
++ .rx_buf = priv->spi_rx_buf,
++ .cs_change = 0,
++ .len = 14,
++ };
++ uint8_t *tx_buf = priv->spi_tx_buf;
++ uint8_t *rx_buf = priv->spi_rx_buf;
++ struct spi_message m;
++ struct sk_buff *skb;
++ struct can_frame *frame;
++ int ret;
+
-+ dev_dbg(&spi->dev, "%s\n", __FUNCTION__);
++ dev_dbg(&spi->dev, "%s\n", __FUNCTION__);
+
-+ skb = dev_alloc_skb(sizeof(struct can_frame));
-+ if (!skb) {
-+ dev_dbg(&spi->dev, "%s: out of memory for Rx'd frame\n", __FUNCTION__);
-+ priv->can.net_stats.rx_dropped++;
-+ return;
-+ }
-+ skb->dev = priv->net;
-+ frame = (struct can_frame *)skb_put(skb, sizeof(struct can_frame));
++ skb = dev_alloc_skb(sizeof(struct can_frame));
++ if (!skb) {
++ dev_dbg(&spi->dev, "%s: out of memory for Rx'd frame\n", __FUNCTION__);
++ priv->can.net_stats.rx_dropped++;
++ return;
++ }
++ skb->dev = priv->net;
++ frame = (struct can_frame *)skb_put(skb, sizeof(struct can_frame));
+
-+ down(&priv->spi_lock);
++ down(&priv->spi_lock);
+
-+ tx_buf[0] = INSTRUCTION_READ_RXB(buf_idx);
++ tx_buf[0] = INSTRUCTION_READ_RXB(buf_idx);
+
-+ spi_message_init(&m);
++ spi_message_init(&m);
+
-+ if (enable_dma) {
-+ t.tx_dma = priv->spi_tx_dma;
-+ t.rx_dma = priv->spi_rx_dma;
-+ m.is_dma_mapped = 1;
-+ }
++ if (enable_dma) {
++ t.tx_dma = priv->spi_tx_dma;
++ t.rx_dma = priv->spi_rx_dma;
++ m.is_dma_mapped = 1;
++ }
+
-+ spi_message_add_tail(&t, &m);
++ spi_message_add_tail(&t, &m);
+
-+ ret = spi_sync(spi, &m);
-+ if (ret < 0)
-+ dev_dbg(&spi->dev, "%s: failed: ret = %d\n", __FUNCTION__, ret);
-+ /* FIXME: Should we exit with an error here? */
++ ret = spi_sync(spi, &m);
++ if (ret < 0)
++ dev_dbg(&spi->dev, "%s: failed: ret = %d\n", __FUNCTION__, ret);
++ /* FIXME: Should we exit with an error here? */
+
-+ if ((rx_buf[2] >> 3) & 0x1) {
-+ /* Extended ID format */
-+ frame->can_id = CAN_EFF_FLAG;
-+ frame->can_id |= (rx_buf[2] << 16) | (rx_buf[3] << 8) | rx_buf[4];
-+ } else {
-+ /* Standard ID format */
-+ frame->can_id = (rx_buf[1] << 3) | (rx_buf[2] >> 5);
-+ }
++ if ((rx_buf[2] >> 3) & 0x1) {
++ /* Extended ID format */
++ frame->can_id = CAN_EFF_FLAG;
++ frame->can_id |= (rx_buf[2] << 16) | (rx_buf[3] << 8) | rx_buf[4];
++ } else {
++ /* Standard ID format */
++ frame->can_id = (rx_buf[1] << 3) | (rx_buf[2] >> 5);
++ }
+
-+ if ((rx_buf[5] >> 6) & 0x1) {
-+ /* Remote transmission request */
-+ frame->can_id |= CAN_RTR_FLAG;
-+ }
++ if ((rx_buf[5] >> 6) & 0x1) {
++ /* Remote transmission request */
++ frame->can_id |= CAN_RTR_FLAG;
++ }
+
-+ dev_dbg(&spi->dev, "%s: can_id rec'd 0x%08X\n", __FUNCTION__, frame->can_id);
++ dev_dbg(&spi->dev, "%s: can_id rec'd 0x%08X\n", __FUNCTION__, frame->can_id);
+
-+ /* Data length */
-+ frame->can_dlc = rx_buf[5] & 0x0f;
-+ memcpy(frame->data, rx_buf + 6, CAN_FRAME_MAX_DATA_LEN);
++ /* Data length */
++ frame->can_dlc = rx_buf[5] & 0x0f;
++ memcpy(frame->data, rx_buf + 6, CAN_FRAME_MAX_DATA_LEN);
+
-+ up(&priv->spi_lock);
++ up(&priv->spi_lock);
+
-+ priv->can.net_stats.rx_packets++;
-+ priv->can.net_stats.rx_bytes += frame->can_dlc;
++ priv->can.net_stats.rx_packets++;
++ priv->can.net_stats.rx_bytes += frame->can_dlc;
+
-+ skb->protocol = __constant_htons(ETH_P_CAN);
-+ skb->pkt_type = PACKET_BROADCAST;
-+ skb->ip_summed = CHECKSUM_UNNECESSARY;
-+ netif_rx(skb);
++ skb->protocol = __constant_htons(ETH_P_CAN);
++ skb->pkt_type = PACKET_BROADCAST;
++ skb->ip_summed = CHECKSUM_UNNECESSARY;
++ netif_rx(skb);
+
-+ return;
++ return;
+}
+
+
+static void mcp251x_hw_sleep(struct spi_device *spi)
+{
-+ mcp251x_write_reg(spi, CANCTRL, CANCTRL_REQOP_SLEEP);
++ mcp251x_write_reg(spi, CANCTRL, CANCTRL_REQOP_SLEEP);
+}
+
+static void mcp251x_hw_wakeup(struct spi_device *spi)
+{
-+ /* Can only wake up by generating a wake-up interrupt. */
-+ mcp251x_write_bits(spi, CANINTE, CANINTE_WAKIE, CANINTE_WAKIE);
-+ mcp251x_write_bits(spi, CANINTF, CANINTF_WAKIF, CANINTF_WAKIF);
++ /* Can only wake up by generating a wake-up interrupt. */
++ mcp251x_write_bits(spi, CANINTE, CANINTE_WAKIE, CANINTE_WAKIE);
++ mcp251x_write_bits(spi, CANINTF, CANINTF_WAKIF, CANINTF_WAKIF);
+}
+
+/* FIXME: modes of operation CONFIG, NORMAL, SLEEP, LISTEN, LOOPBACK */
+static int mcp251x_set_mode(struct net_device *net, uint8_t mode)
+{
-+ return 0;
++ return 0;
+}
+
+static int mcp251x_hard_start_xmit(struct sk_buff *skb, struct net_device *net)
+{
-+ struct mcp251x_priv *priv = netdev_priv(net);
-+ struct spi_device *spi = priv->spi;
-+ struct can_frame *frame;
++ struct mcp251x_priv *priv = netdev_priv(net);
++ struct spi_device *spi = priv->spi;
++ struct can_frame *frame;
+
-+ dev_dbg(&spi->dev, "%s\n", __FUNCTION__);
++ dev_dbg(&spi->dev, "%s\n", __FUNCTION__);
+
-+ if (skb->len != sizeof(struct can_frame)) {
-+ dev_dbg(&spi->dev, "dropping packet - bad length\n");
-+ dev_kfree_skb(skb);
-+ priv->can.net_stats.tx_dropped++;
-+ return 0;
-+ }
++ if (skb->len != sizeof(struct can_frame)) {
++ dev_dbg(&spi->dev, "dropping packet - bad length\n");
++ dev_kfree_skb(skb);
++ priv->can.net_stats.tx_dropped++;
++ return 0;
++ }
+
-+ netif_stop_queue(net);
++ netif_stop_queue(net);
+
-+ frame = (struct can_frame *)skb->data;
++ frame = (struct can_frame *)skb->data;
+
-+ priv->tx_skb = skb;
-+ schedule_work(&priv->tx_work);
++ priv->tx_skb = skb;
++ schedule_work(&priv->tx_work);
+
-+ return 0;
++ return 0;
+}
+
+
+static int mcp251x_do_set_mode(struct net_device *net, can_mode_t mode)
+{
-+ struct mcp251x_priv *priv = netdev_priv(net);
-+ struct spi_device *spi = priv->spi;
++ struct mcp251x_priv *priv = netdev_priv(net);
++ struct spi_device *spi = priv->spi;
+
-+ dev_dbg(&spi->dev, "%s (unimplemented)\n", __FUNCTION__);
++ dev_dbg(&spi->dev, "%s (unimplemented)\n", __FUNCTION__);
+
-+ switch (mode) {
-+ default:
-+ return -EOPNOTSUPP;
-+ }
++ switch (mode) {
++ default:
++ return -EOPNOTSUPP;
++ }
+
-+ return 0;
++ return 0;
+}
+
+
+static int mcp251x_open(struct net_device *net)
+{
-+ struct mcp251x_priv *priv = netdev_priv(net);
-+ struct spi_device *spi = priv->spi;
-+ struct mcp251x_platform_data *pdata = spi->dev.platform_data;
++ struct mcp251x_priv *priv = netdev_priv(net);
++ struct spi_device *spi = priv->spi;
++ struct mcp251x_platform_data *pdata = spi->dev.platform_data;
+
-+ dev_dbg(&spi->dev, "%s\n", __FUNCTION__);
++ dev_dbg(&spi->dev, "%s\n", __FUNCTION__);
+
-+ if (pdata->transceiver_enable)
-+ pdata->transceiver_enable(1);
++ if (pdata->transceiver_enable)
++ pdata->transceiver_enable(1);
+
-+ mcp251x_hw_wakeup(spi);
++ mcp251x_hw_wakeup(spi);
+
-+ /* Enable interrupts */
-+ mcp251x_write_reg(spi, CANINTE,
-+ CANINTE_ERRIE | CANINTE_TX2IE | CANINTE_TX1IE |
-+ CANINTE_TX0IE | CANINTE_RX1IE | CANINTE_RX0IE );
++ /* Enable interrupts */
++ mcp251x_write_reg(spi, CANINTE,
++ CANINTE_ERRIE | CANINTE_TX2IE | CANINTE_TX1IE |
++ CANINTE_TX0IE | CANINTE_RX1IE | CANINTE_RX0IE );
+
-+ if (loopback) {
-+ /* Put device into loopback mode */
-+ mcp251x_write_reg(spi, CANCTRL, CANCTRL_REQOP_LOOPBACK);
-+ } else {
-+ /* Put device into normal mode */
-+ mcp251x_write_reg(spi, CANCTRL, CANCTRL_REQOP_NORMAL);
++ if (loopback) {
++ /* Put device into loopback mode */
++ mcp251x_write_reg(spi, CANCTRL, CANCTRL_REQOP_LOOPBACK);
++ } else {
++ /* Put device into normal mode */
++ mcp251x_write_reg(spi, CANCTRL, CANCTRL_REQOP_NORMAL);
+
-+ /* Wait for the device to enter normal mode */
-+ while (mcp251x_read_reg(spi, CANSTAT) & 0xE0)
-+ udelay(10);
-+ }
++ /* Wait for the device to enter normal mode */
++ while (mcp251x_read_reg(spi, CANSTAT) & 0xE0)
++ udelay(10);
++ }
+
-+ return 0;
++ return 0;
+}
+
+static int mcp251x_stop(struct net_device *net)
+{
-+ struct mcp251x_priv *priv = netdev_priv(net);
-+ struct spi_device *spi = priv->spi;
-+ struct mcp251x_platform_data *pdata = spi->dev.platform_data;
++ struct mcp251x_priv *priv = netdev_priv(net);
++ struct spi_device *spi = priv->spi;
++ struct mcp251x_platform_data *pdata = spi->dev.platform_data;
+
-+ dev_dbg(&spi->dev, "%s\n", __FUNCTION__);
++ dev_dbg(&spi->dev, "%s\n", __FUNCTION__);
+
-+ /* Disable and clear pending interrupts */
-+ mcp251x_write_reg(spi, CANINTE, 0x00);
-+ mcp251x_write_reg(spi, CANINTF, 0x00);
++ /* Disable and clear pending interrupts */
++ mcp251x_write_reg(spi, CANINTE, 0x00);
++ mcp251x_write_reg(spi, CANINTF, 0x00);
+
-+ mcp251x_hw_sleep(spi);
++ mcp251x_hw_sleep(spi);
+
-+ if (pdata->transceiver_enable)
-+ pdata->transceiver_enable(0);
++ if (pdata->transceiver_enable)
++ pdata->transceiver_enable(0);
+
-+ return 0;
++ return 0;
+}
+
+static int mcp251x_do_set_bit_time(struct net_device *net, struct can_bittime *bt)
+{
-+ struct mcp251x_priv *priv = netdev_priv(net);
-+ struct spi_device *spi = priv->spi;
-+ uint8_t state;
++ struct mcp251x_priv *priv = netdev_priv(net);
++ struct spi_device *spi = priv->spi;
++ uint8_t state;
+
-+ dev_dbg(&spi->dev, "%s: BRP = %d, PropSeg = %d, PS1 = %d,"
-+ " PS2 = %d, SJW = %d\n", __FUNCTION__, bt->std.brp,
-+ bt->std.prop_seg, bt->std.phase_seg1, bt->std.phase_seg2,
-+ bt->std.sjw);
++ dev_dbg(&spi->dev, "%s: BRP = %d, PropSeg = %d, PS1 = %d,"
++ " PS2 = %d, SJW = %d\n", __FUNCTION__, bt->std.brp,
++ bt->std.prop_seg, bt->std.phase_seg1, bt->std.phase_seg2,
++ bt->std.sjw);
+
-+ /* Store original mode and set mode to config */
-+ state = mcp251x_read_reg(spi, CANSTAT) & CANCTRL_REQOP_MASK;
-+ mcp251x_write_bits(spi, CANCTRL, CANCTRL_REQOP_MASK, CANCTRL_REQOP_CONF);
++ /* Store original mode and set mode to config */
++ state = mcp251x_read_reg(spi, CANSTAT) & CANCTRL_REQOP_MASK;
++ mcp251x_write_bits(spi, CANCTRL, CANCTRL_REQOP_MASK, CANCTRL_REQOP_CONF);
+
-+ mcp251x_write_reg(spi, CNF1, ((bt->std.sjw - 1) << 6) | bt->std.brp);
-+ mcp251x_write_reg(spi, CNF2, CNF2_BTLMODE | ((bt->std.phase_seg1 - 1) << 3) | (bt->std.prop_seg - 1));
-+ mcp251x_write_bits(spi, CNF3, CNF3_PHSEG2_MASK, (bt->std.phase_seg2 - 1));
++ mcp251x_write_reg(spi, CNF1, ((bt->std.sjw - 1) << 6) | bt->std.brp);
++ mcp251x_write_reg(spi, CNF2, CNF2_BTLMODE | ((bt->std.phase_seg1 - 1) << 3) |
++ (bt->std.prop_seg - 1));
++ mcp251x_write_bits(spi, CNF3, CNF3_PHSEG2_MASK, (bt->std.phase_seg2 - 1));
+
-+ /* Restore original state */
-+ mcp251x_write_bits(spi, CANCTRL, CANCTRL_REQOP_MASK, state);
++ /* Restore original state */
++ mcp251x_write_bits(spi, CANCTRL, CANCTRL_REQOP_MASK, state);
+
-+ return 0;
++ return 0;
+}
+
+
+static int mcp251x_do_get_state(struct net_device *net, can_state_t *state)
+{
-+ struct mcp251x_priv *priv = netdev_priv(net);
-+ struct spi_device *spi = priv->spi;
-+ uint8_t eflag;
++ struct mcp251x_priv *priv = netdev_priv(net);
++ struct spi_device *spi = priv->spi;
++ uint8_t eflag;
+
-+ eflag = mcp251x_read_reg(spi, EFLG);
++ eflag = mcp251x_read_reg(spi, EFLG);
+
-+ if (eflag & EFLG_TXBO) {
-+ *state = CAN_STATE_BUS_OFF;
-+ } else if (eflag & (EFLG_RXEP | EFLG_TXEP)) {
-+ *state = CAN_STATE_BUS_PASSIVE;
-+ } else if (eflag & EFLG_EWARN) {
-+ *state = CAN_STATE_BUS_WARNING;
-+ } else {
-+ *state = CAN_STATE_ACTIVE;
-+ }
++ if (eflag & EFLG_TXBO) {
++ *state = CAN_STATE_BUS_OFF;
++ } else if (eflag & (EFLG_RXEP | EFLG_TXEP)) {
++ *state = CAN_STATE_BUS_PASSIVE;
++ } else if (eflag & EFLG_EWARN) {
++ *state = CAN_STATE_BUS_WARNING;
++ } else {
++ *state = CAN_STATE_ACTIVE;
++ }
+
-+ return 0;
++ return 0;
+}
+
+
+static void mcp251x_tx_work_handler(struct work_struct *work)
+{
-+ struct mcp251x_priv *priv = container_of(work, struct mcp251x_priv, tx_work);
-+ struct spi_device *spi = priv->spi;
-+ struct can_frame *frame = (struct can_frame *)priv->tx_skb->data;
++ struct mcp251x_priv *priv = container_of(work, struct mcp251x_priv, tx_work);
++ struct spi_device *spi = priv->spi;
++ struct can_frame *frame = (struct can_frame *)priv->tx_skb->data;
+
-+ dev_dbg(&spi->dev, "%s\n", __FUNCTION__);
++ dev_dbg(&spi->dev, "%s\n", __FUNCTION__);
+
-+ if (frame->can_dlc > CAN_FRAME_MAX_DATA_LEN)
-+ frame->can_dlc = CAN_FRAME_MAX_DATA_LEN;
++ if (frame->can_dlc > CAN_FRAME_MAX_DATA_LEN)
++ frame->can_dlc = CAN_FRAME_MAX_DATA_LEN;
+
-+ /* FIXME: use all 3 Tx buffers */
-+ mcp251x_hw_tx(spi, frame, 0);
++ /* FIXME: use all 3 Tx buffers */
++ mcp251x_hw_tx(spi, frame, 0);
+
-+ return;
++ return;
+}
+
+
+static void mcp251x_irq_work_handler(struct work_struct *work)
+{
-+ struct mcp251x_priv *priv = container_of(work, struct mcp251x_priv, irq_work);
-+ struct spi_device *spi = priv->spi;
-+ struct net_device *net = priv->net;
-+ uint8_t intf;
++ struct mcp251x_priv *priv = container_of(work, struct mcp251x_priv, irq_work);
++ struct spi_device *spi = priv->spi;
++ struct net_device *net = priv->net;
++ uint8_t intf;
+
-+ for (;;) {
-+ intf = mcp251x_read_reg(spi, CANINTF);
-+ if (intf == 0x00)
-+ break;
++ for (;;) {
++ intf = mcp251x_read_reg(spi, CANINTF);
++ if (intf == 0x00)
++ break;
+
-+ dev_dbg(&spi->dev, "interrupt:%s%s%s%s%s%s%s%s\n",
-+ (intf & CANINTF_MERRF) ? " MERR":"",
-+ (intf & CANINTF_WAKIF) ? " WAK":"",
-+ (intf & CANINTF_ERRIF) ? " ERR":"",
-+ (intf & CANINTF_TX2IF) ? " TX2":"",
-+ (intf & CANINTF_TX1IF) ? " TX1":"",
-+ (intf & CANINTF_TX0IF) ? " TX0":"",
-+ (intf & CANINTF_RX1IF) ? " RX1":"",
-+ (intf & CANINTF_RX0IF) ? " RX0":"");
++ dev_dbg(&spi->dev, "interrupt:%s%s%s%s%s%s%s%s\n",
++ (intf & CANINTF_MERRF) ? " MERR":"",
++ (intf & CANINTF_WAKIF) ? " WAK":"",
++ (intf & CANINTF_ERRIF) ? " ERR":"",
++ (intf & CANINTF_TX2IF) ? " TX2":"",
++ (intf & CANINTF_TX1IF) ? " TX1":"",
++ (intf & CANINTF_TX0IF) ? " TX0":"",
++ (intf & CANINTF_RX1IF) ? " RX1":"",
++ (intf & CANINTF_RX0IF) ? " RX0":"");
+
-+ if (intf & CANINTF_MERRF) {
-+ uint8_t txbnctrl;
-+ /* if there are no pending Tx buffers, restart queue */
-+ txbnctrl = mcp251x_read_reg(spi, TXBCTRL(0));
-+ if (!(txbnctrl & TXBCTRL_TXREQ))
-+ netif_wake_queue(net);
-+ }
++ if (intf & CANINTF_MERRF) {
++ uint8_t txbnctrl;
++ /* if there are no pending Tx buffers, restart queue */
++ txbnctrl = mcp251x_read_reg(spi, TXBCTRL(0));
++ if (!(txbnctrl & TXBCTRL_TXREQ))
++ netif_wake_queue(net);
++ }
+
-+ if (intf & CANINTF_ERRIF) {
-+ uint8_t eflg = mcp251x_read_reg(spi, EFLG);
++ if (intf & CANINTF_ERRIF) {
++ uint8_t eflg = mcp251x_read_reg(spi, EFLG);
+
-+ dev_dbg(&spi->dev, "EFLG = 0x%02x\n", eflg);
++ dev_dbg(&spi->dev, "EFLG = 0x%02x\n", eflg);
+
-+ if (eflg & (EFLG_RX0OVR | EFLG_RX1OVR)) {
-+ if (eflg & EFLG_RX0OVR)
-+ priv->can.net_stats.rx_over_errors++;
-+ if (eflg & EFLG_RX1OVR)
-+ priv->can.net_stats.rx_over_errors++;
-+ mcp251x_write_reg(spi, EFLG, 0x00);
-+ }
-+ }
++ if (eflg & (EFLG_RX0OVR | EFLG_RX1OVR)) {
++ if (eflg & EFLG_RX0OVR)
++ priv->can.net_stats.rx_over_errors++;
++ if (eflg & EFLG_RX1OVR)
++ priv->can.net_stats.rx_over_errors++;
++ mcp251x_write_reg(spi, EFLG, 0x00);
++ }
++ }
+
-+ if (intf & (CANINTF_TX2IF | CANINTF_TX1IF | CANINTF_TX0IF)) {
-+ priv->can.net_stats.tx_packets++;
-+ priv->can.net_stats.tx_bytes += ((struct can_frame *)(priv->tx_skb->data))->can_dlc;
-+ dev_kfree_skb(priv->tx_skb);
-+ netif_wake_queue(net);
-+ }
++ if (intf & (CANINTF_TX2IF | CANINTF_TX1IF | CANINTF_TX0IF)) {
++ priv->can.net_stats.tx_packets++;
++ priv->can.net_stats.tx_bytes += ((struct can_frame *)(priv->tx_skb->data))->can_dlc;
++ dev_kfree_skb(priv->tx_skb);
++ netif_wake_queue(net);
++ }
+
-+ if (intf & CANINTF_RX0IF)
-+ mcp251x_hw_rx(spi, 0);
++ if (intf & CANINTF_RX0IF)
++ mcp251x_hw_rx(spi, 0);
+
-+ if (intf & CANINTF_RX1IF)
-+ mcp251x_hw_rx(spi, 1);
++ if (intf & CANINTF_RX1IF)
++ mcp251x_hw_rx(spi, 1);
+
-+ mcp251x_write_bits(spi, CANINTF, intf, 0x00);
-+ }
++ mcp251x_write_bits(spi, CANINTF, intf, 0x00);
++ }
+
-+ mcp251x_read_reg(spi, CANSTAT);
++ mcp251x_read_reg(spi, CANSTAT);
+
-+ dev_dbg(&spi->dev, "interrupt ended\n");
++ dev_dbg(&spi->dev, "interrupt ended\n");
+
-+ return;
++ return;
+}
+
+
-+static irqreturn_t
-+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
-+mcp251x_can_isr(int irq, void *dev_id, struct pt_regs *r)
-+#else
-+mcp251x_can_isr(int irq, void *dev_id)
-+#endif
++static irqreturn_t mcp251x_can_isr(int irq, void *dev_id)
+{
-+ struct net_device *net = (struct net_device *)dev_id;
-+ struct mcp251x_priv *priv = netdev_priv(net);
-+ struct spi_device *spi = priv->spi;
++ struct net_device *net = (struct net_device *)dev_id;
++ struct mcp251x_priv *priv = netdev_priv(net);
++ struct spi_device *spi = priv->spi;
+
-+ dev_dbg(&spi->dev, "%s\n", __FUNCTION__);
++ dev_dbg(&spi->dev, "%s\n", __FUNCTION__);
+
-+ /* Schedule bottom half */
-+ schedule_work(&priv->irq_work);
++ /* Schedule bottom half */
++ schedule_work(&priv->irq_work);
+
-+ return IRQ_HANDLED;
++ return IRQ_HANDLED;
+}
+
+static void mcp251x_hw_reset(struct spi_device *spi)
+{
-+ struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);
-+ int ret;
++ struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);
++ int ret;
+
-+ down(&priv->spi_lock);
++ down(&priv->spi_lock);
+
-+ priv->spi_tx_buf[0] = INSTRUCTION_RESET;
++ priv->spi_tx_buf[0] = INSTRUCTION_RESET;
+
-+ ret = spi_write(spi, priv->spi_tx_buf, 1);
-+ if (ret < 0)
-+ dev_dbg(&spi->dev, "%s: failed: ret = %d\n", __FUNCTION__, ret);
++ ret = spi_write(spi, priv->spi_tx_buf, 1);
++ if (ret < 0)
++ dev_dbg(&spi->dev, "%s: failed: ret = %d\n", __FUNCTION__, ret);
+
-+ up(&priv->spi_lock);
++ up(&priv->spi_lock);
+
-+ return;
++ return;
+}
+
+static struct net_device *alloc_mcp251x_netdev(int sizeof_priv)
+{
-+ struct net_device *net;
-+ struct mcp251x_priv *priv;
++ struct net_device *net;
++ struct mcp251x_priv *priv;
+
-+ net = alloc_candev(sizeof_priv);
-+ if (!net) {
-+ return NULL;
-+ }
++ net = alloc_candev(sizeof_priv);
++ if (!net) {
++ return NULL;
++ }
+
-+ priv = netdev_priv(net);
++ priv = netdev_priv(net);
+
-+ net->open = mcp251x_open;
-+ net->stop = mcp251x_stop;
-+ net->hard_start_xmit = mcp251x_hard_start_xmit;
++ net->open = mcp251x_open;
++ net->stop = mcp251x_stop;
++ net->hard_start_xmit = mcp251x_hard_start_xmit;
+
-+ /* Set loopback if module parameter was specified */
-+ if (loopback)
-+ net->flags |= IFF_LOOPBACK;
++ /* Set loopback if module parameter was specified */
++ if (loopback)
++ net->flags |= IFF_LOOPBACK;
+
-+ priv->can.baudrate = 250000;
-+ priv->can.do_set_bit_time = mcp251x_do_set_bit_time;
-+ priv->can.do_get_state = mcp251x_do_get_state;
-+ priv->can.do_set_mode = mcp251x_do_set_mode;
++ priv->can.baudrate = 250000;
++ priv->can.do_set_bit_time = mcp251x_do_set_bit_time;
++ priv->can.do_get_state = mcp251x_do_get_state;
++ priv->can.do_set_mode = mcp251x_do_set_mode;
+
-+ priv->net = net;
++ priv->net = net;
+
-+ return net;
++ return net;
+}
+
+/* Platform file will specify something like:
@@ -777,225 +770,224 @@
+
+static int __devinit mcp251x_can_probe(struct spi_device *spi)
+{
-+ struct net_device *net;
-+ struct mcp251x_priv *priv;
-+ struct mcp251x_platform_data *pdata = spi->dev.platform_data;
-+ struct can_bittime bit_time;
-+ int ret = -ENODEV;
-+ printk("mcp251x probe\n");
-+ if (!pdata) {
-+ /* Platform data is required for osc freq */
-+ goto error_out;
-+ }
++ struct net_device *net;
++ struct mcp251x_priv *priv;
++ struct mcp251x_platform_data *pdata = spi->dev.platform_data;
++ struct can_bittime bit_time;
++ int ret = -ENODEV;
++ printk("mcp251x probe\n");
++ if (!pdata) {
++ /* Platform data is required for osc freq */
++ goto error_out;
++ }
+
-+ /* Allocate can/net device */
-+ net = alloc_mcp251x_netdev(sizeof(struct mcp251x_priv));
-+ if (!net) {
-+ ret = -ENOMEM;
-+ goto error_alloc;
-+ }
++ /* Allocate can/net device */
++ net = alloc_mcp251x_netdev(sizeof(struct mcp251x_priv));
++ if (!net) {
++ ret = -ENOMEM;
++ goto error_alloc;
++ }
+
-+ priv = netdev_priv(net);
-+ dev_set_drvdata(&spi->dev, priv);
++ priv = netdev_priv(net);
++ dev_set_drvdata(&spi->dev, priv);
+
-+ priv->spi = spi;
-+ init_MUTEX(&priv->spi_lock);
++ priv->spi = spi;
++ init_MUTEX(&priv->spi_lock);
+
-+ /* Not sure why / 4... mcp251x pre-divides by 2 */
-+ priv->can.can_sys_clock = pdata->oscillator_frequency / 4;
++ /* Not sure why / 4... mcp251x pre-divides by 2 */
++ priv->can.can_sys_clock = pdata->oscillator_frequency / 4;
+
-+ /* If requested, allocate DMA buffers */
-+ if (enable_dma) {
-+ spi->dev.coherent_dma_mask = DMA_32BIT_MASK;
++ /* If requested, allocate DMA buffers */
++ if (enable_dma) {
++ spi->dev.coherent_dma_mask = DMA_32BIT_MASK;
+
-+ /* Minimum coherent DMA allocation is PAGE_SIZE, so allocate
++ /* Minimum coherent DMA allocation is PAGE_SIZE, so allocate
+ that much and share it between Tx and Rx DMA buffers. */
-+ priv->spi_tx_buf = dma_alloc_coherent(&spi->dev,
-+ PAGE_SIZE, &priv->spi_tx_dma, GFP_DMA);
++ priv->spi_tx_buf = dma_alloc_coherent(&spi->dev,
++ PAGE_SIZE, &priv->spi_tx_dma, GFP_DMA);
+
-+ if (priv->spi_tx_buf) {
-+ priv->spi_rx_buf = (uint8_t *)(priv->spi_tx_buf +
-+ (PAGE_SIZE / 2));
-+ priv->spi_rx_dma = (dma_addr_t)(priv->spi_tx_dma +
-+ (PAGE_SIZE / 2));
-+ } else {
-+ /* Fall back to non-DMA */
-+ enable_dma = 0;
-+ }
-+ }
++ if (priv->spi_tx_buf) {
++ priv->spi_rx_buf = (uint8_t *)(priv->spi_tx_buf +
++ (PAGE_SIZE / 2));
++ priv->spi_rx_dma = (dma_addr_t)(priv->spi_tx_dma +
++ (PAGE_SIZE / 2));
++ } else {
++ /* Fall back to non-DMA */
++ enable_dma = 0;
++ }
++ }
+
-+ /* Allocate non-DMA buffers */
-+ if (!enable_dma) {
-+ priv->spi_tx_buf = kmalloc(SPI_TRANSFER_BUF_LEN, GFP_KERNEL);
-+ if (!priv->spi_tx_buf) {
-+ ret = -ENOMEM;
-+ goto error_tx_buf;
-+ }
-+ priv->spi_rx_buf = kmalloc(SPI_TRANSFER_BUF_LEN, GFP_KERNEL);
-+ if (!priv->spi_tx_buf) {
-+ ret = -ENOMEM;
-+ goto error_rx_buf;
-+ }
-+ }
++ /* Allocate non-DMA buffers */
++ if (!enable_dma) {
++ priv->spi_tx_buf = kmalloc(SPI_TRANSFER_BUF_LEN, GFP_KERNEL);
++ if (!priv->spi_tx_buf) {
++ ret = -ENOMEM;
++ goto error_tx_buf;
++ }
++ priv->spi_rx_buf = kmalloc(SPI_TRANSFER_BUF_LEN, GFP_KERNEL);
++ if (!priv->spi_tx_buf) {
++ ret = -ENOMEM;
++ goto error_rx_buf;
++ }
++ }
+
-+ /* Call out to platform specific setup */
-+ if (pdata->board_specific_setup)
-+ pdata->board_specific_setup(spi);
++ /* Call out to platform specific setup */
++ if (pdata->board_specific_setup)
++ pdata->board_specific_setup(spi);
+
-+ /* Call out to platform specific hardware reset */
-+ if (pdata->device_reset)
-+ pdata->device_reset(spi);
++ /* Call out to platform specific hardware reset */
++ if (pdata->device_reset)
++ pdata->device_reset(spi);
+
-+ /* Register IRQ */
-+ if (spi->irq >= 0) {
-+ if (request_irq(spi->irq, mcp251x_can_isr, IRQF_TRIGGER_FALLING, DEVICE_NAME, net) < 0) {
-+ dev_err(&spi->dev, "failed to acquire irq %d\n", spi->irq);
-+ goto error_irq;
-+ }
-+ }
++ /* Register IRQ */
++ if (spi->irq >= 0) {
++ if (request_irq(spi->irq, mcp251x_can_isr, IRQF_TRIGGER_FALLING, DEVICE_NAME, net) < 0) {
++ dev_err(&spi->dev, "failed to acquire irq %d\n", spi->irq);
++ goto error_irq;
++ }
++ }
+
-+ SET_NETDEV_DEV(net, &spi->dev);
++ SET_NETDEV_DEV(net, &spi->dev);
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
-+ SET_MODULE_OWNER(THIS_MODULE);
++ SET_MODULE_OWNER(THIS_MODULE);
+#endif
+
-+ INIT_WORK(&priv->tx_work, mcp251x_tx_work_handler);
-+ INIT_WORK(&priv->irq_work, mcp251x_irq_work_handler);
++ INIT_WORK(&priv->tx_work, mcp251x_tx_work_handler);
++ INIT_WORK(&priv->irq_work, mcp251x_irq_work_handler);
+
-+ /* Configure the SPI bus */
-+ spi->mode = SPI_MODE_2;
-+ spi->bits_per_word = 8;
-+ spi_setup(spi);
++ /* Configure the SPI bus */
++ spi->mode = SPI_MODE_2;
++ spi->bits_per_word = 8;
++ spi_setup(spi);
+
-+ mcp251x_hw_reset(spi);
++ mcp251x_hw_reset(spi);
+
-+ /* Set initial baudrate */
-+ ret = can_calc_bit_time(&priv->can, priv->can.baudrate, &bit_time.std);
-+ if (ret != 0)
-+ dev_err(&spi->dev, "unable to calculate initial baudrate!\n");
-+ else {
-+ bit_time.type = CAN_BITTIME_STD;
-+ ret = priv->can.do_set_bit_time(net, &bit_time);
-+ if (ret)
-+ dev_err(&spi->dev, "unable to set initial baudrate!\n");
-+ }
++ /* Set initial baudrate */
++ ret = can_calc_bit_time(&priv->can, priv->can.baudrate, &bit_time.std);
++ if (ret != 0)
++ dev_err(&spi->dev, "unable to calculate initial baudrate!\n");
++ else {
++ bit_time.type = CAN_BITTIME_STD;
++ ret = priv->can.do_set_bit_time(net, &bit_time);
++ if (ret)
++ dev_err(&spi->dev, "unable to set initial baudrate!\n");
++ }
+
-+ mcp251x_hw_sleep(spi);
++ mcp251x_hw_sleep(spi);
+
-+ ret = register_netdev(net);
-+ if (ret >= 0) {
-+ dev_info(&spi->dev, "probed%s\n",
-+ (loopback) ? " (loopback)" : "");
-+ return ret;
-+ }
++ ret = register_netdev(net);
++ if (ret >= 0) {
++ dev_info(&spi->dev, "probed%s\n", (loopback) ? " (loopback)" : "");
++ return ret;
++ }
+
-+ free_irq(spi->irq, net);
++ free_irq(spi->irq, net);
+error_irq:
-+ if (!enable_dma)
-+ kfree(priv->spi_rx_buf);
++ if (!enable_dma)
++ kfree(priv->spi_rx_buf);
+error_rx_buf:
-+ if (!enable_dma)
-+ kfree(priv->spi_tx_buf);
++ if (!enable_dma)
++ kfree(priv->spi_tx_buf);
+error_tx_buf:
-+ free_candev(net);
-+ if (enable_dma) {
-+ dma_free_coherent(&spi->dev, PAGE_SIZE,
-+ priv->spi_tx_buf, priv->spi_tx_dma);
-+ }
++ free_candev(net);
++ if (enable_dma) {
++ dma_free_coherent(&spi->dev, PAGE_SIZE,
++ priv->spi_tx_buf, priv->spi_tx_dma);
++ }
+error_alloc:
-+ dev_err(&spi->dev, "probe failed\n");
++ dev_err(&spi->dev, "probe failed\n");
+error_out:
-+ return ret;
++ return ret;
+}
+
+static int __devexit mcp251x_can_remove(struct spi_device *spi)
+{
-+ struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);
-+ struct net_device *net = priv->net;
++ struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);
++ struct net_device *net = priv->net;
+
-+ work_clear_pending(&priv->tx_work);
++ work_clear_pending(&priv->tx_work);
+
-+ free_irq(spi->irq, net);
-+ work_clear_pending(&priv->irq_work);
++ free_irq(spi->irq, net);
++ work_clear_pending(&priv->irq_work);
+
-+ flush_scheduled_work();
++ flush_scheduled_work();
+
-+ if (enable_dma) {
-+ dma_free_coherent(&spi->dev, PAGE_SIZE,
-+ priv->spi_tx_buf, priv->spi_tx_dma);
-+ } else {
-+ kfree(priv->spi_tx_buf);
-+ kfree(priv->spi_rx_buf);
-+ }
++ if (enable_dma) {
++ dma_free_coherent(&spi->dev, PAGE_SIZE,
++ priv->spi_tx_buf, priv->spi_tx_dma);
++ } else {
++ kfree(priv->spi_tx_buf);
++ kfree(priv->spi_rx_buf);
++ }
+
-+ unregister_netdev(net);
-+ free_candev(net);
++ unregister_netdev(net);
++ free_candev(net);
+
-+ return 0;
++ return 0;
+}
+
+#ifdef CONFIG_PM
+static int mcp251x_can_suspend(struct spi_device *spi, pm_message_t state)
+{
-+ struct mcp251x_platform_data *pdata = spi->dev.platform_data;
-+ struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);
-+ struct net_device *net = priv->net;
++ struct mcp251x_platform_data *pdata = spi->dev.platform_data;
++ struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);
++ struct net_device *net = priv->net;
+
-+ if (!netif_running(net))
-+ return 0;
++ if (!netif_running(net))
++ return 0;
+
-+ netif_device_detach(net);
++ netif_device_detach(net);
+
-+ mcp251x_hw_sleep(spi);
-+ if (pdata->transceiver_enable)
-+ pdata->transceiver_enable(0);
++ mcp251x_hw_sleep(spi);
++ if (pdata->transceiver_enable)
++ pdata->transceiver_enable(0);
+
-+ return 0;
++ return 0;
+}
+
+static int mcp251x_can_resume(struct spi_device *spi)
+{
-+ struct mcp251x_platform_data *pdata = spi->dev.platform_data;
-+ struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);
-+ struct net_device *net = priv->net;
++ struct mcp251x_platform_data *pdata = spi->dev.platform_data;
++ struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);
++ struct net_device *net = priv->net;
+
-+ if (!netif_running(net))
-+ return 0;
++ if (!netif_running(net))
++ return 0;
+
-+ if (pdata->transceiver_enable)
-+ pdata->transceiver_enable(1);
-+ mcp251x_hw_wakeup(spi);
++ if (pdata->transceiver_enable)
++ pdata->transceiver_enable(1);
++ mcp251x_hw_wakeup(spi);
+
-+ netif_device_attach(net);
++ netif_device_attach(net);
+
-+ return 0;
++ return 0;
+}
+#endif
+
+static struct spi_driver mcp251x_can_driver = {
-+ .driver = {
-+ .name = DEVICE_NAME,
-+ //.bus = &spi_bus_type,
-+ .owner = THIS_MODULE,
-+ },
++ .driver = {
++ .name = DEVICE_NAME,
++ .bus = &spi_bus_type,
++ .owner = THIS_MODULE,
++ },
+
-+ .probe = mcp251x_can_probe,
-+ .remove = __devexit_p(mcp251x_can_remove),
++ .probe = mcp251x_can_probe,
++ .remove = __devexit_p(mcp251x_can_remove),
+#ifdef CONFIG_PM
-+ .suspend = mcp251x_can_suspend,
-+ .resume = mcp251x_can_resume,
++ .suspend = mcp251x_can_suspend,
++ .resume = mcp251x_can_resume,
+#endif
+};
+
+static int __init mcp251x_can_init(void)
+{
-+ printk("mcp251x init\n");
-+ return spi_register_driver(&mcp251x_can_driver);
++ printk("mcp251x init\n");
++ return spi_register_driver(&mcp251x_can_driver);
+}
+
+static void __exit mcp251x_can_exit(void)
+{
-+ spi_unregister_driver(&mcp251x_can_driver);
++ spi_unregister_driver(&mcp251x_can_driver);
+}
+
+module_init(mcp251x_can_init);
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
