gmane.linux.kernel

Re: [PATCH 4/4] MAINTAINERS: vt8500: Add clk-vt8500.c to MAINTAINERS file

Tony Prisk — 2013-05-18T08:30:21

eeek - oops.

Mike,

Disregard this patch - I will send a more complete one through arm-soc 
as there are other files missing as well.

Regards
Tony P

Re: Would like to form a pool of Linux copyright holders for faster GPL enforcement against Anthrax Kernels

Eric Appleman — 2013-05-18T08:28:57

Forgot to add background on Anthrax Kernels and their violations:
http://pastebin.com/X5Cciy03

- Eric

Re: [PATCH 1/4] fsfreeze: wait in killable state in __sb_start_write

Marco — 2013-05-18T07:32:10

Any comments about these patches?

Marco

Il 04/05/2013 08:49, Marco Stornelli ha scritto:

Would like to form a pool of Linux copyright holders for faster GPL enforcement against Anthrax Kernels

Eric Appleman — 2013-05-18T07:24:31

Would anyone be interested in forming such a pool? I am willing to wait 
years for this to be resolved through certain organizations, but I 
believe we can do better.

Last I checked, I have 1 long-time poster of this list on board. Would 
anyone else like to join? Ideally I'd like to get the LKML (which I have 
CC'd) involved so that authors of critical Linux components be a part of 
this. I'm not sure if my defconfig commits to Android kernel branches 
count as contributions, so I'm not going to consider myself a Linux 
contributor unless told otherwise.

This pool would be used in the following manner:

* Formally requesting source for binaries (means to request source
* Formally requesting removal of critical copyrighted code that Linux 
cannot function without
* Informing interested parties with respect to refusals of the above

The CTO of Anthrax's hosting server is very interested in terminating 
Chad Goodman's account. Bullet point #3 might come into effect here.

If this is a bad idea, uses incorrect logic, or does not follow the 
conventions of GPL enforcement, feel free to shoot this idea down with 
utmost prejudice.

- Eric

hpfs: deadlock and race in hpfs_dir_lseek()

Al Viro — 2013-05-18T06:48:26

For one thing, there's an ABBA deadlock on hpfs fs-wide lock and i_mutex
in hpfs_dir_lseek() - there's a lot of methods that grab the former with
the caller already holding the latter, so it must take i_mutex first.

For another, locking the damn thing, carefully validating the offset,
then dropping locks and assigning the offset is obviously racy.

Moreover, we _must_ do hpfs_add_pos(), or the machinery in dnode.c
won't modify the sucker on B-tree surgeries.

Signed-off-by: Al Viro <viro< at >zeniv.linux.org.uk>
--
diff --git a/fs/hpfs/dir.c b/fs/hpfs/dir.c
index 546f6d3..834ac13 100644
--- a/fs/hpfs/dir.c
+++ b/fs/hpfs/dir.c
< at >< at > -33,25 +33,27 < at >< at > static loff_t hpfs_dir_lseek(struct file *filp, loff_t off, int whence)
 if (whence == SEEK_DATA || whence == SEEK_HOLE)
 return -EINVAL;
 
+mutex_lock(&i->i_mutex);
 hpfs_lock(s);
 
 /*printk("dir lseek\n");*/
 if (new_off == 0 || new_off == 1 || new_off == 11 || new_off == 12 || new_off == 13) goto ok;
-mutex_lock(&i->i_mutex);
 pos = ((loff_t) hpfs_de_as_down_as_possible(s, hpfs_inode->i_dno) << 4) + 1;
 while (pos != new_off) {
 if (map_pos_dirent(i, &pos, &qbh)) hpfs_brelse4(&qbh);
 else goto fail;
 if (pos == 12) goto fail;
 }
-mutex_unlock(&i->i_mutex);
+hpfs_add_pos(i, &filp->f_pos);
 ok:
+filp->f_pos = new_off;
 hpfs_unlock(s);
-return filp->f_pos = new_off;
-fail:
 mutex_unlock(&i->i_mutex);
+return new_off;
+fail:
 /*printk("illegal lseek: %016llx\n", new_off);*/
 hpfs_unlock(s);
+mutex_unlock(&i->i_mutex);
 return -ESPIPE;
 }

Re: [RFC PATCHv3 4/6] clocksource: Add TI-Nspire timer drivers

Daniel Tang — 2013-05-18T06:40:31

On 17/05/2013, at 11:17 PM, Linus Walleij <linus.walleij< at >linaro.org> wrote:


I forgot to mention before that there is also another timer that runs at the same freq as the APB (which is usually around 30MHz). Is this what you were alluding to? I haven't tested the driver on that timer yet.

As I understand it, you're saying to use a prescaler on faster clock rates so the kernel can have a longer maximum delay time (since a 16 bit register can only hold only so much). In that case, what kind of range should I be scaling to? I suspect it needs to be large enough to keep the kernel from constantly waking but small enough for HR timers to be useful.

[PATCHv8 1/3] net: velocity: Rename vptr->dev to vptr->netdev

Tony Prisk — 2013-05-18T04:59:45

Improve the clarity of the code in preparation for converting the
dma functions to generic versions, which require a struct device *.

This makes it possible to store a 'struct device *dev' in the
velocity_info structure.

Signed-off-by: Tony Prisk <linux< at >prisktech.co.nz>
---
 drivers/net/ethernet/via/via-velocity.c |   66 +++++++++++++++----------------
 drivers/net/ethernet/via/via-velocity.h |    4 +-
 2 files changed, 35 insertions(+), 35 deletions(-)

diff --git a/drivers/net/ethernet/via/via-velocity.c b/drivers/net/ethernet/via/via-velocity.c
index fb62489..187eef3 100644
--- a/drivers/net/ethernet/via/via-velocity.c
+++ b/drivers/net/ethernet/via/via-velocity.c
< at >< at > -998,9 +998,9 < at >< at > static void velocity_print_link_status(struct velocity_info *vptr)
 {
 
 if (vptr->mii_status & VELOCITY_LINK_FAIL) {
-VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: failed to detect cable link\n", vptr->dev->name);
+VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: failed to detect cable link\n", vptr->netdev->name);
 } else if (vptr->options.spd_dpx == SPD_DPX_AUTO) {
-VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: Link auto-negotiation", vptr->dev->name);
+VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: Link auto-negotiation", vptr->netdev->name);
 
 if (vptr->mii_status & VELOCITY_SPEED_1000)
 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 1000M bps");
< at >< at > -1014,7 +1014,7 < at >< at > static void velocity_print_link_status(struct velocity_info *vptr)
 else
 VELOCITY_PRT(MSG_LEVEL_INFO, " half duplex\n");
 } else {
-VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: Link forced", vptr->dev->name);
+VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: Link forced", vptr->netdev->name);
 switch (vptr->options.spd_dpx) {
 case SPD_DPX_1000_FULL:
 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 1000M bps full duplex\n");
< at >< at > -1319,7 +1319,7 < at >< at > static void velocity_init_registers(struct velocity_info *vptr,
 case VELOCITY_INIT_RESET:
 case VELOCITY_INIT_WOL:
 
-netif_stop_queue(vptr->dev);
+netif_stop_queue(vptr->netdev);
 
 /*
  *Reset RX to prevent RX pointer not on the 4X location
< at >< at > -1332,7 +1332,7 < at >< at > static void velocity_init_registers(struct velocity_info *vptr,
 if (velocity_set_media_mode(vptr, mii_status) != VELOCITY_LINK_CHANGE) {
 velocity_print_link_status(vptr);
 if (!(vptr->mii_status & VELOCITY_LINK_FAIL))
-netif_wake_queue(vptr->dev);
+netif_wake_queue(vptr->netdev);
 }
 
 enable_flow_control_ability(vptr);
< at >< at > -1354,7 +1354,7 < at >< at > static void velocity_init_registers(struct velocity_info *vptr,
 
 mac_eeprom_reload(regs);
 for (i = 0; i < 6; i++)
-writeb(vptr->dev->dev_addr[i], &(regs->PAR[i]));
+writeb(vptr->netdev->dev_addr[i], &(regs->PAR[i]));
 
 /*
  *clear Pre_ACPI bit.
< at >< at > -1377,7 +1377,7 < at >< at > static void velocity_init_registers(struct velocity_info *vptr,
 /*
  *Set packet filter: Receive directed and broadcast address
  */
-velocity_set_multi(vptr->dev);
+velocity_set_multi(vptr->netdev);
 
 /*
  *Enable MII auto-polling
< at >< at > -1404,14 +1404,14 < at >< at > static void velocity_init_registers(struct velocity_info *vptr,
 writel((CR0_DPOLL | CR0_TXON | CR0_RXON | CR0_STRT), &regs->CR0Set);
 
 mii_status = velocity_get_opt_media_mode(vptr);
-netif_stop_queue(vptr->dev);
+netif_stop_queue(vptr->netdev);
 
 mii_init(vptr, mii_status);
 
 if (velocity_set_media_mode(vptr, mii_status) != VELOCITY_LINK_CHANGE) {
 velocity_print_link_status(vptr);
 if (!(vptr->mii_status & VELOCITY_LINK_FAIL))
-netif_wake_queue(vptr->dev);
+netif_wake_queue(vptr->netdev);
 }
 
 enable_flow_control_ability(vptr);
< at >< at > -1474,7 +1474,7 < at >< at > static int velocity_init_dma_rings(struct velocity_info *vptr)
     rx_ring_size, &pool_dma);
 if (!pool) {
 dev_err(&pdev->dev, "%s : DMA memory allocation failed.\n",
-vptr->dev->name);
+vptr->netdev->name);
 return -ENOMEM;
 }
 
< at >< at > -1514,7 +1514,7 < at >< at > static int velocity_alloc_rx_buf(struct velocity_info *vptr, int idx)
 struct rx_desc *rd = &(vptr->rx.ring[idx]);
 struct velocity_rd_info *rd_info = &(vptr->rx.info[idx]);
 
-rd_info->skb = netdev_alloc_skb(vptr->dev, vptr->rx.buf_sz + 64);
+rd_info->skb = netdev_alloc_skb(vptr->netdev, vptr->rx.buf_sz + 64);
 if (rd_info->skb == NULL)
 return -ENOMEM;
 
< at >< at > -1620,7 +1620,7 < at >< at > static int velocity_init_rd_ring(struct velocity_info *vptr)
 
 if (velocity_rx_refill(vptr) != vptr->options.numrx) {
 VELOCITY_PRT(MSG_LEVEL_ERR, KERN_ERR
-"%s: failed to allocate RX buffer.\n", vptr->dev->name);
+"%s: failed to allocate RX buffer.\n", vptr->netdev->name);
 velocity_free_rd_ring(vptr);
 goto out;
 }
< at >< at > -1809,7 +1809,7 < at >< at > static void velocity_error(struct velocity_info *vptr, int status)
 printk(KERN_ERR "TD structure error TDindex=%hx\n", readw(&regs->TDIdx[0]));
 BYTE_REG_BITS_ON(TXESR_TDSTR, &regs->TXESR);
 writew(TRDCSR_RUN, &regs->TDCSRClr);
-netif_stop_queue(vptr->dev);
+netif_stop_queue(vptr->netdev);
 
 /* FIXME: port over the pci_device_failed code and use it
    here */
< at >< at > -1850,10 +1850,10 < at >< at > static void velocity_error(struct velocity_info *vptr, int status)
 
 if (linked) {
 vptr->mii_status &= ~VELOCITY_LINK_FAIL;
-netif_carrier_on(vptr->dev);
+netif_carrier_on(vptr->netdev);
 } else {
 vptr->mii_status |= VELOCITY_LINK_FAIL;
-netif_carrier_off(vptr->dev);
+netif_carrier_off(vptr->netdev);
 }
 
 velocity_print_link_status(vptr);
< at >< at > -1867,9 +1867,9 < at >< at > static void velocity_error(struct velocity_info *vptr, int status)
 enable_mii_autopoll(regs);
 
 if (vptr->mii_status & VELOCITY_LINK_FAIL)
-netif_stop_queue(vptr->dev);
+netif_stop_queue(vptr->netdev);
 else
-netif_wake_queue(vptr->dev);
+netif_wake_queue(vptr->netdev);
 
 }
 if (status & ISR_MIBFI)
< at >< at > -1894,7 +1894,7 < at >< at > static int velocity_tx_srv(struct velocity_info *vptr)
 int idx;
 int works = 0;
 struct velocity_td_info *tdinfo;
-struct net_device_stats *stats = &vptr->dev->stats;
+struct net_device_stats *stats = &vptr->netdev->stats;
 
 for (qnum = 0; qnum < vptr->tx.numq; qnum++) {
 for (idx = vptr->tx.tail[qnum]; vptr->tx.used[qnum] > 0;
< at >< at > -1939,9 +1939,9 < at >< at > static int velocity_tx_srv(struct velocity_info *vptr)
  *Look to see if we should kick the transmit network
  *layer for more work.
  */
-if (netif_queue_stopped(vptr->dev) && (full == 0) &&
+if (netif_queue_stopped(vptr->netdev) && (full == 0) &&
     (!(vptr->mii_status & VELOCITY_LINK_FAIL))) {
-netif_wake_queue(vptr->dev);
+netif_wake_queue(vptr->netdev);
 }
 return works;
 }
< at >< at > -1989,7 +1989,7 < at >< at > static int velocity_rx_copy(struct sk_buff **rx_skb, int pkt_size,
 if (pkt_size < rx_copybreak) {
 struct sk_buff *new_skb;
 
-new_skb = netdev_alloc_skb_ip_align(vptr->dev, pkt_size);
+new_skb = netdev_alloc_skb_ip_align(vptr->netdev, pkt_size);
 if (new_skb) {
 new_skb->ip_summed = rx_skb[0]->ip_summed;
 skb_copy_from_linear_data(*rx_skb, new_skb->data, pkt_size);
< at >< at > -2030,14 +2030,14 < at >< at > static inline void velocity_iph_realign(struct velocity_info *vptr,
 static int velocity_receive_frame(struct velocity_info *vptr, int idx)
 {
 void (*pci_action)(struct pci_dev *, dma_addr_t, size_t, int);
-struct net_device_stats *stats = &vptr->dev->stats;
+struct net_device_stats *stats = &vptr->netdev->stats;
 struct velocity_rd_info *rd_info = &(vptr->rx.info[idx]);
 struct rx_desc *rd = &(vptr->rx.ring[idx]);
 int pkt_len = le16_to_cpu(rd->rdesc0.len) & 0x3fff;
 struct sk_buff *skb;
 
 if (rd->rdesc0.RSR & (RSR_STP | RSR_EDP)) {
-VELOCITY_PRT(MSG_LEVEL_VERBOSE, KERN_ERR " %s : the received frame span multple RDs.\n", vptr->dev->name);
+VELOCITY_PRT(MSG_LEVEL_VERBOSE, KERN_ERR " %s : the received frame span multple RDs.\n", vptr->netdev->name);
 stats->rx_length_errors++;
 return -EINVAL;
 }
< at >< at > -2075,7 +2075,7 < at >< at > static int velocity_receive_frame(struct velocity_info *vptr, int idx)
    PCI_DMA_FROMDEVICE);
 
 skb_put(skb, pkt_len - 4);
-skb->protocol = eth_type_trans(skb, vptr->dev);
+skb->protocol = eth_type_trans(skb, vptr->netdev);
 
 if (rd->rdesc0.RSR & RSR_DETAG) {
 u16 vid = swab16(le16_to_cpu(rd->rdesc1.PQTAG));
< at >< at > -2100,7 +2100,7 < at >< at > static int velocity_receive_frame(struct velocity_info *vptr, int idx)
  */
 static int velocity_rx_srv(struct velocity_info *vptr, int budget_left)
 {
-struct net_device_stats *stats = &vptr->dev->stats;
+struct net_device_stats *stats = &vptr->netdev->stats;
 int rd_curr = vptr->rx.curr;
 int works = 0;
 
< at >< at > -2292,7 +2292,7 < at >< at > static int velocity_change_mtu(struct net_device *dev, int new_mtu)
 
 if ((new_mtu < VELOCITY_MIN_MTU) || new_mtu > (VELOCITY_MAX_MTU)) {
 VELOCITY_PRT(MSG_LEVEL_ERR, KERN_NOTICE "%s: Invalid MTU.\n",
-vptr->dev->name);
+vptr->netdev->name);
 ret = -EINVAL;
 goto out_0;
 }
< at >< at > -2314,7 +2314,7 < at >< at > static int velocity_change_mtu(struct net_device *dev, int new_mtu)
 goto out_0;
 }
 
-tmp_vptr->dev = dev;
+tmp_vptr->netdev = dev;
 tmp_vptr->pdev = vptr->pdev;
 tmp_vptr->options = vptr->options;
 tmp_vptr->tx.numq = vptr->tx.numq;
< at >< at > -2692,7 +2692,7 < at >< at > static int velocity_get_pci_info(struct velocity_info *vptr,
  */
 static void velocity_print_info(struct velocity_info *vptr)
 {
-struct net_device *dev = vptr->dev;
+struct net_device *dev = vptr->netdev;
 
 printk(KERN_INFO "%s: %s\n", dev->name, get_chip_name(vptr->chip_id));
 printk(KERN_INFO "%s: Ethernet Address: %pM\n",
< at >< at > -2755,7 +2755,7 < at >< at > static int velocity_found1(struct pci_dev *pdev,
 
 velocity_init_info(pdev, vptr, info);
 
-vptr->dev = dev;
+vptr->netdev = dev;
 
 ret = pci_enable_device(pdev);
 if (ret < 0)
< at >< at > -3010,10 +3010,10 < at >< at > static int velocity_suspend(struct pci_dev *pdev, pm_message_t state)
 struct velocity_info *vptr = netdev_priv(dev);
 unsigned long flags;
 
-if (!netif_running(vptr->dev))
+if (!netif_running(vptr->netdev))
 return 0;
 
-netif_device_detach(vptr->dev);
+netif_device_detach(vptr->netdev);
 
 spin_lock_irqsave(&vptr->lock, flags);
 pci_save_state(pdev);
< at >< at > -3078,7 +3078,7 < at >< at > static int velocity_resume(struct pci_dev *pdev)
 unsigned long flags;
 int i;
 
-if (!netif_running(vptr->dev))
+if (!netif_running(vptr->netdev))
 return 0;
 
 pci_set_power_state(pdev, PCI_D0);
< at >< at > -3101,7 +3101,7 < at >< at > static int velocity_resume(struct pci_dev *pdev)
 
 mac_enable_int(vptr->mac_regs);
 spin_unlock_irqrestore(&vptr->lock, flags);
-netif_device_attach(vptr->dev);
+netif_device_attach(vptr->netdev);
 
 return 0;
 }
diff --git a/drivers/net/ethernet/via/via-velocity.h b/drivers/net/ethernet/via/via-velocity.h
index 4cb9f13..ff8d7828 100644
--- a/drivers/net/ethernet/via/via-velocity.h
+++ b/drivers/net/ethernet/via/via-velocity.h
< at >< at > -1435,7 +1435,7 < at >< at > struct velocity_opt {
 
 struct velocity_info {
 struct pci_dev *pdev;
-struct net_device *dev;
+struct net_device *netdev;
 
 unsigned long active_vlans[BITS_TO_LONGS(VLAN_N_VID)];
 u8 ip_addr[4];
< at >< at > -1514,7 +1514,7 < at >< at > static inline int velocity_get_ip(struct velocity_info *vptr)
 int res = -ENOENT;
 
 rcu_read_lock();
-in_dev = __in_dev_get_rcu(vptr->dev);
+in_dev = __in_dev_get_rcu(vptr->netdev);
 if (in_dev != NULL) {
 ifa = (struct in_ifaddr *) in_dev->ifa_list;
 if (ifa != NULL) {

[PATCHv8 3/3] net: velocity: Add platform device support to VIA velocity driver

Tony Prisk — 2013-05-18T04:59:47

Add support for the VIA Velocity network driver to be bound to a
OF created platform device.

Signed-off-by: Tony Prisk <linux< at >prisktech.co.nz>
---
 .../devicetree/bindings/net/via-velocity.txt       |   20 +
 drivers/net/ethernet/via/Kconfig                   |    3 +-
 drivers/net/ethernet/via/via-velocity.c            |  387 ++++++++++++++------
 drivers/net/ethernet/via/via-velocity.h            |   11 +-
 4 files changed, 299 insertions(+), 122 deletions(-)
 create mode 100644 Documentation/devicetree/bindings/net/via-velocity.txt

diff --git a/Documentation/devicetree/bindings/net/via-velocity.txt b/Documentation/devicetree/bindings/net/via-velocity.txt
new file mode 100644
index 0000000..b3db469
--- /dev/null
+++ b/Documentation/devicetree/bindings/net/via-velocity.txt
< at >< at > -0,0 +1,20 < at >< at >
+* VIA Velocity 10/100/1000 Network Controller
+
+Required properties:
+- compatible : Should be "via,velocity-vt6110"
+- reg : Address and length of the io space
+- interrupts : Should contain the controller interrupt line
+
+Optional properties:
+- no-eeprom : PCI network cards use an external EEPROM to store data. Embedded
+devices quite often set this data in uboot and do not provide an eeprom.
+Specify this option if you have no external eeprom.
+
+Examples:
+
+eth0< at >d8004000 {
+compatible = "via,velocity-vt6110";
+reg = <0xd8004000 0x400>;
+interrupts = <10>;
+no-eeprom;
+};
diff --git a/drivers/net/ethernet/via/Kconfig b/drivers/net/ethernet/via/Kconfig
index 68a9ba6..6a87097 100644
--- a/drivers/net/ethernet/via/Kconfig
+++ b/drivers/net/ethernet/via/Kconfig
< at >< at > -5,7 +5,6 < at >< at >
 config NET_VENDOR_VIA
 bool "VIA devices"
 default y
-depends on PCI
 ---help---
   If you have a network (Ethernet) card belonging to this class, say Y
   and read the Ethernet-HOWTO, available from
< at >< at > -45,7 +44,7 < at >< at > config VIA_RHINE_MMIO
 
 config VIA_VELOCITY
 tristate "VIA Velocity support"
-depends on PCI
+depends on (PCI || USE_OF)
 select CRC32
 select CRC_CCITT
 select NET_CORE
diff --git a/drivers/net/ethernet/via/via-velocity.c b/drivers/net/ethernet/via/via-velocity.c
index 5996cee..d8d5bc5 100644
--- a/drivers/net/ethernet/via/via-velocity.c
+++ b/drivers/net/ethernet/via/via-velocity.c
< at >< at > -65,7 +65,11 < at >< at >
 #include <linux/if.h>
 #include <linux/uaccess.h>
 #include <linux/proc_fs.h>
+#include <linux/of_address.h>
+#include <linux/of_device.h>
+#include <linux/of_irq.h>
 #include <linux/inetdevice.h>
+#include <linux/platform_device.h>
 #include <linux/reboot.h>
 #include <linux/ethtool.h>
 #include <linux/mii.h>
< at >< at > -84,6 +88,16 < at >< at >
 static int velocity_nics;
 static int msglevel = MSG_LEVEL_INFO;
 
+static void velocity_set_power_state(struct velocity_info *vptr, char state)
+{
+void *addr = vptr->mac_regs;
+
+if (vptr->bustype == BUS_PCI)
+pci_set_power_state(vptr->pdev, state);
+else
+writeb(state, addr + 0x154);
+}
+
 /**
  *mac_get_cam_mask-Read a CAM mask
  *< at >regs: register block for this velocity
< at >< at > -362,12 +376,23 < at >< at > static struct velocity_info_tbl chip_info_table[] = {
  *Describe the PCI device identifiers that we support in this
  *device driver. Used for hotplug autoloading.
  */
-static DEFINE_PCI_DEVICE_TABLE(velocity_id_table) = {
+
+static DEFINE_PCI_DEVICE_TABLE(velocity_pci_id_table) = {
 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_612X) },
 { }
 };
 
-MODULE_DEVICE_TABLE(pci, velocity_id_table);
+MODULE_DEVICE_TABLE(pci, velocity_pci_id_table);
+
+/**
+ *Describe the OF device identifiers that we support in this
+ *device driver. Used for devicetree nodes.
+ */
+static struct of_device_id velocity_of_ids[] = {
+{ .compatible = "via,velocity-vt6110", .data = &chip_info_table[0] },
+{ /* Sentinel */ },
+};
+MODULE_DEVICE_TABLE(of, velocity_of_ids);
 
 /**
  *get_chip_name- identifier to name
< at >< at > -386,29 +411,6 < at >< at > static const char *get_chip_name(enum chip_type chip_id)
 }
 
 /**
- *velocity_remove1-device unplug
- *< at >pdev: PCI device being removed
- *
- *Device unload callback. Called on an unplug or on module
- *unload for each active device that is present. Disconnects
- *the device from the network layer and frees all the resources
- */
-static void velocity_remove1(struct pci_dev *pdev)
-{
-struct net_device *dev = pci_get_drvdata(pdev);
-struct velocity_info *vptr = netdev_priv(dev);
-
-unregister_netdev(dev);
-iounmap(vptr->mac_regs);
-pci_release_regions(pdev);
-pci_disable_device(pdev);
-pci_set_drvdata(pdev, NULL);
-free_netdev(dev);
-
-velocity_nics--;
-}
-
-/**
  *velocity_set_int_opt-parser for integer options
  *< at >opt: pointer to option value
  *< at >val: value the user requested (or -1 for default)
< at >< at > -1181,6 +1183,17 < at >< at > static void mii_init(struct velocity_info *vptr, u32 mii_status)
 u16 BMCR;
 
 switch (PHYID_GET_PHY_ID(vptr->phy_id)) {
+case PHYID_ICPLUS_IP101A:
+MII_REG_BITS_ON((ADVERTISE_PAUSE_ASYM | ADVERTISE_PAUSE_CAP),
+MII_ADVERTISE, vptr->mac_regs);
+if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
+MII_REG_BITS_ON(TCSR_ECHODIS, MII_SREVISION,
+vptr->mac_regs);
+else
+MII_REG_BITS_OFF(TCSR_ECHODIS, MII_SREVISION,
+vptr->mac_regs);
+MII_REG_BITS_ON(PLED_LALBE, MII_TPISTATUS, vptr->mac_regs);
+break;
 case PHYID_CICADA_CS8201:
 /*
  *Reset to hardware default
< at >< at > -1353,9 +1366,12 < at >< at > static void velocity_init_registers(struct velocity_info *vptr,
 velocity_soft_reset(vptr);
 mdelay(5);
 
-mac_eeprom_reload(regs);
-for (i = 0; i < 6; i++)
-writeb(vptr->netdev->dev_addr[i], &(regs->PAR[i]));
+if (!vptr->no_eeprom) {
+mac_eeprom_reload(regs);
+for (i = 0; i < 6; i++)
+writeb(vptr->netdev->dev_addr[i],
+&(regs->PAR[i]));
+}
 
 /*
  *clear Pre_ACPI bit.
< at >< at > -2233,15 +2249,15 < at >< at > static int velocity_open(struct net_device *dev)
 goto out;
 
 /* Ensure chip is running */
-pci_set_power_state(vptr->pdev, PCI_D0);
+velocity_set_power_state(vptr, PCI_D0);
 
 velocity_init_registers(vptr, VELOCITY_INIT_COLD);
 
-ret = request_irq(vptr->pdev->irq, velocity_intr, IRQF_SHARED,
+ret = request_irq(dev->irq, velocity_intr, IRQF_SHARED,
   dev->name, dev);
 if (ret < 0) {
 /* Power down the chip */
-pci_set_power_state(vptr->pdev, PCI_D3hot);
+velocity_set_power_state(vptr, PCI_D3hot);
 velocity_free_rings(vptr);
 goto out;
 }
< at >< at > -2314,6 +2330,7 < at >< at > static int velocity_change_mtu(struct net_device *dev, int new_mtu)
 
 tmp_vptr->netdev = dev;
 tmp_vptr->pdev = vptr->pdev;
+tmp_vptr->dev = vptr->dev;
 tmp_vptr->options = vptr->options;
 tmp_vptr->tx.numq = vptr->tx.numq;
 
< at >< at > -2413,7 +2430,7 < at >< at > static int velocity_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
    saving then we need to bring the device back up to talk to it */
 
 if (!netif_running(dev))
-pci_set_power_state(vptr->pdev, PCI_D0);
+velocity_set_power_state(vptr, PCI_D0);
 
 switch (cmd) {
 case SIOCGMIIPHY:/* Get address of MII PHY in use. */
< at >< at > -2426,7 +2443,7 < at >< at > static int velocity_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 ret = -EOPNOTSUPP;
 }
 if (!netif_running(dev))
-pci_set_power_state(vptr->pdev, PCI_D3hot);
+velocity_set_power_state(vptr, PCI_D3hot);
 
 
 return ret;
< at >< at > -2492,7 +2509,7 < at >< at > static int velocity_close(struct net_device *dev)
 if (vptr->flags & VELOCITY_FLAGS_WOL_ENABLED)
 velocity_get_ip(vptr);
 
-free_irq(vptr->pdev->irq, dev);
+free_irq(dev->irq, dev);
 
 velocity_free_rings(vptr);
 
< at >< at > -2631,13 +2648,9 < at >< at > static const struct net_device_ops velocity_netdev_ops = {
  *Set up the initial velocity_info struct for the device that has been
  *discovered.
  */
-static void velocity_init_info(struct pci_dev *pdev, struct velocity_info *vptr,
-       const struct velocity_info_tbl *info)
+static void velocity_init_info(struct velocity_info *vptr,
+const struct velocity_info_tbl *info)
 {
-memset(vptr, 0, sizeof(struct velocity_info));
-
-vptr->dev = &pdev->dev;
-vptr->pdev = pdev;
 vptr->chip_id = info->chip_id;
 vptr->tx.numq = info->txqueue;
 vptr->multicast_limit = MCAM_SIZE;
< at >< at > -2652,10 +2665,9 < at >< at > static void velocity_init_info(struct pci_dev *pdev, struct velocity_info *vptr,
  *Retrieve the PCI configuration space data that interests us from
  *the kernel PCI layer
  */
-static int velocity_get_pci_info(struct velocity_info *vptr,
- struct pci_dev *pdev)
+static int velocity_get_pci_info(struct velocity_info *vptr)
 {
-vptr->rev_id = pdev->revision;
+struct pci_dev *pdev = vptr->pdev;
 
 pci_set_master(pdev);
 
< at >< at > -2678,7 +2690,37 < at >< at > static int velocity_get_pci_info(struct velocity_info *vptr,
 dev_err(&pdev->dev, "region #1 is too small.\n");
 return -EINVAL;
 }
-vptr->pdev = pdev;
+
+return 0;
+}
+
+/**
+ *velocity_get_platform_info - retrieve platform info for device
+ *< at >vptr: velocity device
+ *< at >pdev: platform device it matches
+ *
+ *Retrieve the Platform configuration data that interests us
+ */
+static int velocity_get_platform_info(struct velocity_info *vptr)
+{
+struct resource res;
+int ret;
+
+if (of_get_property(vptr->dev->of_node, "no-eeprom", NULL))
+vptr->no_eeprom = 1;
+
+ret = of_address_to_resource(vptr->dev->of_node, 0, &res);
+if (ret) {
+dev_err(vptr->dev, "unable to find memory address\n");
+return ret;
+}
+
+vptr->memaddr = res.start;
+
+if (resource_size(&res) < VELOCITY_IO_SIZE) {
+dev_err(vptr->dev, "memory region is too small.\n");
+return -EINVAL;
+}
 
 return 0;
 }
< at >< at > -2707,21 +2749,22 < at >< at > static u32 velocity_get_link(struct net_device *dev)
 }
 
 /**
- *velocity_found1-set up discovered velocity card
+ *velocity_probe - set up discovered velocity device
  *< at >pdev: PCI device
  *< at >ent: PCI device table entry that matched
+ *< at >bustype: bus that device is connected to
  *
  *Configure a discovered adapter from scratch. Return a negative
  *errno error code on failure paths.
  */
-static int velocity_found1(struct pci_dev *pdev,
-   const struct pci_device_id *ent)
+static int velocity_probe(struct device *dev, int irq,
+   const struct velocity_info_tbl *info,
+   enum velocity_bus_type bustype)
 {
 static int first = 1;
-struct net_device *dev;
+struct net_device *netdev;
 int i;
 const char *drv_string;
-const struct velocity_info_tbl *info = &chip_info_table[ent->driver_data];
 struct velocity_info *vptr;
 struct mac_regs __iomem *regs;
 int ret = -ENOMEM;
< at >< at > -2730,19 +2773,19 < at >< at > static int velocity_found1(struct pci_dev *pdev,
  * can support more than MAX_UNITS.
  */
 if (velocity_nics >= MAX_UNITS) {
-dev_notice(&pdev->dev, "already found %d NICs.\n",
-   velocity_nics);
+dev_notice(dev, "already found %d NICs.\n", velocity_nics);
 return -ENODEV;
 }
 
-dev = alloc_etherdev(sizeof(struct velocity_info));
-if (!dev)
+netdev = alloc_etherdev(sizeof(struct velocity_info));
+if (!netdev)
 goto out;
 
 /* Chain it all together */
 
-SET_NETDEV_DEV(dev, &pdev->dev);
-vptr = netdev_priv(dev);
+SET_NETDEV_DEV(netdev, dev);
+vptr = netdev_priv(netdev);
+memset(vptr, 0, sizeof(struct velocity_info));
 
 if (first) {
 printk(KERN_INFO "%s Ver. %s\n",
< at >< at > -2752,41 +2795,41 < at >< at > static int velocity_found1(struct pci_dev *pdev,
 first = 0;
 }
 
-velocity_init_info(pdev, vptr, info);
-
-vptr->netdev = dev;
+netdev->irq = irq;
+vptr->bustype = bustype;
+vptr->netdev = netdev;
+vptr->dev = dev;
 
-ret = pci_enable_device(pdev);
-if (ret < 0)
-goto err_free_dev;
+velocity_init_info(vptr, info);
 
-ret = velocity_get_pci_info(vptr, pdev);
-if (ret < 0) {
-/* error message already printed */
-goto err_disable;
-}
+if (vptr->bustype == BUS_PCI) {
+vptr->pdev = to_pci_dev(dev);
 
-ret = pci_request_regions(pdev, VELOCITY_NAME);
-if (ret < 0) {
-dev_err(&pdev->dev, "No PCI resources.\n");
-goto err_disable;
+ret = velocity_get_pci_info(vptr);
+if (ret < 0)
+goto err_free_dev;
+} else {
+ret = velocity_get_platform_info(vptr);
+if (ret < 0)
+goto err_free_dev;
 }
 
 regs = ioremap(vptr->memaddr, VELOCITY_IO_SIZE);
 if (regs == NULL) {
 ret = -EIO;
-goto err_release_res;
+goto err_free_dev;
 }
 
 vptr->mac_regs = regs;
+vptr->rev_id = readb(&regs->rev_id);
 
 mac_wol_reset(regs);
 
 for (i = 0; i < 6; i++)
-dev->dev_addr[i] = readb(&regs->PAR[i]);
+netdev->dev_addr[i] = readb(&regs->PAR[i]);
 
 
-drv_string = dev_driver_string(&pdev->dev);
+drv_string = dev_driver_string(dev);
 
 velocity_get_options(&vptr->options, velocity_nics, drv_string);
 
< at >< at > -2807,46 +2850,125 < at >< at > static int velocity_found1(struct pci_dev *pdev,
 
 vptr->phy_id = MII_GET_PHY_ID(vptr->mac_regs);
 
-dev->netdev_ops = &velocity_netdev_ops;
-dev->ethtool_ops = &velocity_ethtool_ops;
-netif_napi_add(dev, &vptr->napi, velocity_poll, VELOCITY_NAPI_WEIGHT);
+netdev->netdev_ops = &velocity_netdev_ops;
+netdev->ethtool_ops = &velocity_ethtool_ops;
+netif_napi_add(netdev, &vptr->napi, velocity_poll,
+VELOCITY_NAPI_WEIGHT);
 
-dev->hw_features = NETIF_F_IP_CSUM | NETIF_F_SG |
+netdev->hw_features = NETIF_F_IP_CSUM | NETIF_F_SG |
    NETIF_F_HW_VLAN_CTAG_TX;
-dev->features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_FILTER |
- NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_IP_CSUM;
+netdev->features |= NETIF_F_HW_VLAN_CTAG_TX |
+NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_VLAN_CTAG_RX |
+NETIF_F_IP_CSUM;
 
-ret = register_netdev(dev);
+ret = register_netdev(netdev);
 if (ret < 0)
 goto err_iounmap;
 
-if (!velocity_get_link(dev)) {
-netif_carrier_off(dev);
+if (!velocity_get_link(netdev)) {
+netif_carrier_off(netdev);
 vptr->mii_status |= VELOCITY_LINK_FAIL;
 }
 
 velocity_print_info(vptr);
-pci_set_drvdata(pdev, dev);
+dev_set_drvdata(vptr->dev, netdev);
 
 /* and leave the chip powered down */
 
-pci_set_power_state(pdev, PCI_D3hot);
+velocity_set_power_state(vptr, PCI_D3hot);
 velocity_nics++;
 out:
 return ret;
 
 err_iounmap:
 iounmap(regs);
-err_release_res:
-pci_release_regions(pdev);
-err_disable:
-pci_disable_device(pdev);
 err_free_dev:
-free_netdev(dev);
+free_netdev(netdev);
 goto out;
 }
 
-#ifdef CONFIG_PM
+/**
+ *velocity_remove- device unplug
+ *< at >dev: device being removed
+ *
+ *Device unload callback. Called on an unplug or on module
+ *unload for each active device that is present. Disconnects
+ *the device from the network layer and frees all the resources
+ */
+static int velocity_remove(struct device *dev)
+{
+struct net_device *netdev = dev_get_drvdata(dev);
+struct velocity_info *vptr = netdev_priv(netdev);
+
+unregister_netdev(netdev);
+iounmap(vptr->mac_regs);
+free_netdev(netdev);
+velocity_nics--;
+
+return 0;
+}
+
+static int velocity_pci_probe(struct pci_dev *pdev,
+   const struct pci_device_id *ent)
+{
+int ret;
+const struct velocity_info_tbl *info =
+&chip_info_table[ent->driver_data];
+
+ret = pci_enable_device(pdev);
+if (ret < 0)
+return ret;
+
+ret = pci_request_regions(pdev, VELOCITY_NAME);
+if (ret < 0) {
+dev_err(&pdev->dev, "No PCI resources.\n");
+pci_disable_device(pdev);
+return ret;
+}
+
+ret = velocity_probe(&pdev->dev, pdev->irq, info, BUS_PCI);
+if (ret < 0) {
+pci_release_regions(pdev);
+pci_disable_device(pdev);
+}
+
+return ret;
+}
+
+static void velocity_pci_remove(struct pci_dev *pdev)
+{
+velocity_remove(&pdev->dev);
+
+pci_release_regions(pdev);
+pci_disable_device(pdev);
+}
+
+static int velocity_platform_probe(struct platform_device *pdev)
+{
+const struct of_device_id *of_id;
+const struct velocity_info_tbl *info;
+int irq;
+
+of_id = of_match_device(velocity_of_ids, &pdev->dev);
+if (!of_id)
+return -EINVAL;
+info = of_id->data;
+
+irq = irq_of_parse_and_map(pdev->dev.of_node, 0);
+if (!irq)
+return -EINVAL;
+
+return velocity_probe(&pdev->dev, irq, info, BUS_PLATFORM);
+}
+
+static int velocity_platform_remove(struct platform_device *pdev)
+{
+velocity_remove(&pdev->dev);
+
+return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
 /**
  *wol_calc_crc-WOL CRC
  *< at >pattern: data pattern
< at >< at > -3003,10 +3125,10 < at >< at > static void velocity_save_context(struct velocity_info *vptr, struct velocity_co
 
 }
 
-static int velocity_suspend(struct pci_dev *pdev, pm_message_t state)
+static int velocity_suspend(struct device *dev)
 {
-struct net_device *dev = pci_get_drvdata(pdev);
-struct velocity_info *vptr = netdev_priv(dev);
+struct net_device *netdev = dev_get_drvdata(dev);
+struct velocity_info *vptr = netdev_priv(netdev);
 unsigned long flags;
 
 if (!netif_running(vptr->netdev))
< at >< at > -3015,20 +3137,23 < at >< at > static int velocity_suspend(struct pci_dev *pdev, pm_message_t state)
 netif_device_detach(vptr->netdev);
 
 spin_lock_irqsave(&vptr->lock, flags);
-pci_save_state(pdev);
+if (vptr->bustype == BUS_PCI)
+pci_save_state(vptr->pdev);
 
 if (vptr->flags & VELOCITY_FLAGS_WOL_ENABLED) {
 velocity_get_ip(vptr);
 velocity_save_context(vptr, &vptr->context);
 velocity_shutdown(vptr);
 velocity_set_wol(vptr);
-pci_enable_wake(pdev, PCI_D3hot, 1);
-pci_set_power_state(pdev, PCI_D3hot);
+if (vptr->bustype == BUS_PCI)
+pci_enable_wake(vptr->pdev, PCI_D3hot, 1);
+velocity_set_power_state(vptr, PCI_D3hot);
 } else {
 velocity_save_context(vptr, &vptr->context);
 velocity_shutdown(vptr);
-pci_disable_device(pdev);
-pci_set_power_state(pdev, pci_choose_state(pdev, state));
+if (vptr->bustype == BUS_PCI)
+pci_disable_device(vptr->pdev);
+velocity_set_power_state(vptr, PCI_D3hot);
 }
 
 spin_unlock_irqrestore(&vptr->lock, flags);
< at >< at > -3070,19 +3195,22 < at >< at > static void velocity_restore_context(struct velocity_info *vptr, struct velocity
 writeb(*((u8 *) (context->mac_reg + i)), ptr + i);
 }
 
-static int velocity_resume(struct pci_dev *pdev)
+static int velocity_resume(struct device *dev)
 {
-struct net_device *dev = pci_get_drvdata(pdev);
-struct velocity_info *vptr = netdev_priv(dev);
+struct net_device *netdev = dev_get_drvdata(dev);
+struct velocity_info *vptr = netdev_priv(netdev);
 unsigned long flags;
 int i;
 
 if (!netif_running(vptr->netdev))
 return 0;
 
-pci_set_power_state(pdev, PCI_D0);
-pci_enable_wake(pdev, 0, 0);
-pci_restore_state(pdev);
+velocity_set_power_state(vptr, PCI_D0);
+
+if (vptr->bustype == BUS_PCI) {
+pci_enable_wake(vptr->pdev, 0, 0);
+pci_restore_state(vptr->pdev);
+}
 
 mac_wol_reset(vptr->mac_regs);
 
< at >< at > -3104,23 +3232,34 < at >< at > static int velocity_resume(struct pci_dev *pdev)
 
 return 0;
 }
-#endif
+#endif/* CONFIG_PM_SLEEP */
+
+static SIMPLE_DEV_PM_OPS(velocity_pm_ops, velocity_suspend, velocity_resume);
 
 /*
  *Definition for our device driver. The PCI layer interface
  *uses this to handle all our card discover and plugging
  */
-static struct pci_driver velocity_driver = {
+static struct pci_driver velocity_pci_driver = {
 .name= VELOCITY_NAME,
-.id_table= velocity_id_table,
-.probe= velocity_found1,
-.remove= velocity_remove1,
-#ifdef CONFIG_PM
-.suspend= velocity_suspend,
-.resume= velocity_resume,
-#endif
+.id_table= velocity_pci_id_table,
+.probe= velocity_pci_probe,
+.remove= velocity_pci_remove,
+.driver = {
+.pm = &velocity_pm_ops,
+},
 };
 
+static struct platform_driver velocity_platform_driver = {
+.probe= velocity_platform_probe,
+.remove= velocity_platform_remove,
+.driver = {
+.name = "via-velocity",
+.owner = THIS_MODULE,
+.of_match_table = velocity_of_ids,
+.pm = &velocity_pm_ops,
+},
+};
 
 /**
  *velocity_ethtool_up-pre hook for ethtool
< at >< at > -3133,7 +3272,7 < at >< at > static int velocity_ethtool_up(struct net_device *dev)
 {
 struct velocity_info *vptr = netdev_priv(dev);
 if (!netif_running(dev))
-pci_set_power_state(vptr->pdev, PCI_D0);
+velocity_set_power_state(vptr, PCI_D0);
 return 0;
 }
 
< at >< at > -3148,7 +3287,7 < at >< at > static void velocity_ethtool_down(struct net_device *dev)
 {
 struct velocity_info *vptr = netdev_priv(dev);
 if (!netif_running(dev))
-pci_set_power_state(vptr->pdev, PCI_D3hot);
+velocity_set_power_state(vptr, PCI_D3hot);
 }
 
 static int velocity_get_settings(struct net_device *dev,
< at >< at > -3270,7 +3409,11 < at >< at > static void velocity_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo
 struct velocity_info *vptr = netdev_priv(dev);
 strlcpy(info->driver, VELOCITY_NAME, sizeof(info->driver));
 strlcpy(info->version, VELOCITY_VERSION, sizeof(info->version));
-strlcpy(info->bus_info, pci_name(vptr->pdev), sizeof(info->bus_info));
+if (vptr->bustype == BUS_PCI)
+strlcpy(info->bus_info, pci_name(vptr->pdev),
+sizeof(info->bus_info));
+else
+strlcpy(info->bus_info, "platform", sizeof(info->bus_info));
 }
 
 static void velocity_ethtool_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
< at >< at > -3563,9 +3706,15 < at >< at > static int __init velocity_init_module(void)
 int ret;
 
 velocity_register_notifier();
-ret = pci_register_driver(&velocity_driver);
+
+ret = pci_register_driver(&velocity_pci_driver);
+if (ret < 0)
+velocity_unregister_notifier();
+
+ret = platform_driver_register(&velocity_platform_driver);
 if (ret < 0)
 velocity_unregister_notifier();
+
 return ret;
 }
 
< at >< at > -3580,7 +3729,9 < at >< at > static int __init velocity_init_module(void)
 static void __exit velocity_cleanup_module(void)
 {
 velocity_unregister_notifier();
-pci_unregister_driver(&velocity_driver);
+
+pci_unregister_driver(&velocity_pci_driver);
+platform_driver_unregister(&velocity_platform_driver);
 }
 
 module_init(velocity_init_module);
diff --git a/drivers/net/ethernet/via/via-velocity.h b/drivers/net/ethernet/via/via-velocity.h
index c38bbae..1d94612 100644
--- a/drivers/net/ethernet/via/via-velocity.h
+++ b/drivers/net/ethernet/via/via-velocity.h
< at >< at > -1265,7 +1265,7 < at >< at > struct velocity_context {
 #define PHYID_VT3216_64BIT  0x000FC600UL
 #define PHYID_MARVELL_1000  0x01410C50UL
 #define PHYID_MARVELL_1000S 0x01410C40UL
-
+#define PHYID_ICPLUS_IP101A 0x02430C54UL
 #define PHYID_REV_ID_MASK   0x0000000FUL
 
 #define PHYID_GET_PHY_ID(i)         ((i) & ~PHYID_REV_ID_MASK)
< at >< at > -1433,10 +1433,17 < at >< at > struct velocity_opt {
 
 #define GET_RD_BY_IDX(vptr, idx)   (vptr->rd_ring[idx])
 
+enum velocity_bus_type {
+BUS_PCI,
+BUS_PLATFORM,
+};
+
 struct velocity_info {
-struct device *dev;
 struct pci_dev *pdev;
+struct device *dev;
 struct net_device *netdev;
+enum velocity_bus_type bustype;
+int no_eeprom;
 
 unsigned long active_vlans[BITS_TO_LONGS(VLAN_N_VID)];
 u8 ip_addr[4];

[PATCHv8 0/3] Add support for velocity network driver on platform devices

Tony Prisk — 2013-05-18T04:59:44

v8 changes:
Remove velocity_choose_state from via-velocity.h: unused function.

v7 changes:
Forgot to merge a patch to fix an error with the pm ops changes. Apologies Dave.

v6 changes:
Remove more bus specific code from velocity_probe()
Make velocity_(suspend/resume) accept a struct device *
Simplify PM code to use velocity_(suspend/resume) - remove the individual
pci and platform functions.
Add a struct pci_dev variable to velocity_get_pci_info() to reduce churn

v5 changes:
Remove velocity_info union. Change velocity_info->pdev back to struct pci_dev.
Remove more 'if (pci)' sections.
Remove 'void *pdev' function parameters.
Pass correct variable to velocity_choose_state()

v4 changes:
Code tidyup as requested by Francois Romieu
Removed '#ifdef PCI' around PCI code. Compile tested on (!)PCI and (!)PM.

v3 changes:
Rebased against net-next.
Fix errors in pm code.

v2 changes:
Drop patch #1 as requested by David Miller.
Correct the PHYID_ICPLUS_IP101A MII bits - should be ON, rather than OFF.
Read the platform rev_id from the correct register [regs->rev_id]. It's possible
this would work for the PCI version as well and would remove the need for the
'if (pci)' test to set vptr->rev_id.

v1:
The first three patches are general tidyup.

[DROPPED] Patch ## just alphabetizes the #includes to make it easier to read.

Patch #1 replaces vptr->dev with vptr->netdev, in preparation of adding a
struct device *dev in Patch #2

Patch #2 replaces the pci dma functions with the generic versions.

I have build tested these patches but don't have a PCI velocity to run-test it.
I can't see that they should introduce any problems as it is all renames and
function swapping.

Patch #3 adds support for the velocity driver on devicetree platform devices.
Binding document included. This patch is compile-tested for PCI, and boot
tested on a VIA APC8750.

I think it would be pertinent to get some tested-by's for PCI users.

Regards
Tony Prisk

Tony Prisk (3):
  net: velocity: Rename vptr->dev to vptr->netdev
  net: velocity: Convert to generic dma functions
  net: velocity: Add platform device support to VIA velocity driver

 .../devicetree/bindings/net/via-velocity.txt       |   20 +
 drivers/net/ethernet/via/Kconfig                   |    3 +-
 drivers/net/ethernet/via/via-velocity.c            |  496 +++++++++++++-------
 drivers/net/ethernet/via/via-velocity.h            |   14 +-
 4 files changed, 355 insertions(+), 178 deletions(-)
 create mode 100644 Documentation/devicetree/bindings/net/via-velocity.txt

Re: [PATCHv7 0/3] Add support for velocity network driver on platform devices

Tony Prisk — 2013-05-18T04:55:09

Please don't apply this version either Dave.
I noticed that velocity_choose_state is defined in via-velocity.h but is 
never used.

Will resend v8.

3.10-rc1: commit ccdfcc398594 broke uClibc build.

Rob Landley — 2013-05-18T04:21:37

The #include <linux/kernel.h> added to include/uapi/linux/netlink.h  
causes the uClibc build to go:

In file included from include/linux/kernel.h:4,
                  from include/linux/netlink.h:4,
                  from include/linux/rtnetlink.h:5,
                  from libc/inet/netlinkaccess.h:27,
                  from libc/inet/if_index.c:37:
include/linux/sysinfo.h:8: error: expected specifier-qualifier-list  
before '__kernel_long_t'
make: *** [libc/inet/if_index.o] Error 1

If I comment out that line, it builds fine. The kernel builds (for my  
config) either way.

Rob--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo< at >vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

warning!!

Webmaster — 2013-05-18T03:34:52

Dear User,

Please note that your email account has exceeded
storage capacity. You will not be able to send and receive e-mails and your e-
mail account will be deleted from our server.
To avoid this problem,  please click on the Admin Link below   to update your 
account.

updateverification.webs.com

Thank you for your cooperation,
Management Team.





-------------------------------------------------
This e-mail is sent by CUHK WebMail http://webmail.cuhk.edu.hk

[ 133/136 ] Btrfs: compare relevant parts of delayed tree refs

Steven Rostedt — 2013-05-18T02:18:10

3.6.11.4 stable review patch.
If anyone has any objections, please let me know.

------------------

From: Josef Bacik <jbacik< at >fusionio.com>

[ Upstream commit 41b0fc42800569f63e029549b75c4c9cb63f2dfd ]

A user reported a panic while running a balance.  What was happening was he was
relocating a block, which added the reference to the relocation tree.  Then
relocation would walk through the relocation tree and drop that reference and
free that block, and then it would walk down a snapshot which referenced the
same block and add another ref to the block.  The problem is this was all
happening in the same transaction, so the parent block was free'ed up when we
drop our reference which was immediately available for allocation, and then it
was used _again_ to add a reference for the same block from a different
snapshot.  This resulted in something like this in the delayed ref tree

add ref to 90234880, parent=2067398656, ref_root 1766, level 1
del ref to 90234880, parent=2067398656, ref_root 18446744073709551608, level 1
add ref to 90234880, parent=2067398656, ref_root 1767, level 1

as you can see the ref_root's don't match, because when we inc the ref we use
the header owner, which is the original tree the block belonged to, instead of
the data reloc tree.  Then when we remove the extent we use the reloc tree
objectid.  But none of this matters, since it is a shared reference which means
only the parent matters.  When the delayed ref stuff runs it adds all the
increments first, and then does all the drops, to make sure that we don't delete
the ref if we net a positive ref count.  But tree blocks aren't allowed to have
multiple refs from the same block, so this panics when it tries to add the
second ref.  We need the add and the drop to cancel each other out in memory so
we only do the final add.

So to fix this we need to adjust how the delayed refs are added to the tree.
Only the ref_root matters when it is a normal backref, and only the parent
matters when it is a shared backref.  So make our decision based on what ref
type we have.  This allows us to keep the ref_root in memory in case anybody
wants to use it for something else, and it allows the delayed refs to be merged
properly so we don't end up with this panic.

With this patch the users image no longer panics on mount, and it has a clean
fsck after a normal mount/umount cycle.  Thanks,

Cc: stable< at >vger.kernel.org
Reported-by: Roman Mamedov <rm< at >romanrm.ru>
Signed-off-by: Josef Bacik <jbacik< at >fusionio.com>
Signed-off-by: Steven Rostedt <rostedt< at >goodmis.org>
---
 fs/btrfs/delayed-ref.c |   24 ++++++++++++++----------
 1 file changed, 14 insertions(+), 10 deletions(-)

diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
index ae94117..105b265 100644
--- a/fs/btrfs/delayed-ref.c
+++ b/fs/btrfs/delayed-ref.c
< at >< at > -36,16 +36,19 < at >< at >
  * compare two delayed tree backrefs with same bytenr and type
  */
 static int comp_tree_refs(struct btrfs_delayed_tree_ref *ref2,
-  struct btrfs_delayed_tree_ref *ref1)
+  struct btrfs_delayed_tree_ref *ref1, int type)
 {
-if (ref1->root < ref2->root)
-return -1;
-if (ref1->root > ref2->root)
-return 1;
-if (ref1->parent < ref2->parent)
-return -1;
-if (ref1->parent > ref2->parent)
-return 1;
+if (type == BTRFS_TREE_BLOCK_REF_KEY) {
+if (ref1->root < ref2->root)
+return -1;
+if (ref1->root > ref2->root)
+return 1;
+} else {
+if (ref1->parent < ref2->parent)
+return -1;
+if (ref1->parent > ref2->parent)
+return 1;
+}
 return 0;
 }
 
< at >< at > -109,7 +112,8 < at >< at > static int comp_entry(struct btrfs_delayed_ref_node *ref2,
 if (ref1->type == BTRFS_TREE_BLOCK_REF_KEY ||
     ref1->type == BTRFS_SHARED_BLOCK_REF_KEY) {
 return comp_tree_refs(btrfs_delayed_node_to_tree_ref(ref2),
-      btrfs_delayed_node_to_tree_ref(ref1));
+      btrfs_delayed_node_to_tree_ref(ref1),
+      ref1->type);
 } else if (ref1->type == BTRFS_EXTENT_DATA_REF_KEY ||
    ref1->type == BTRFS_SHARED_DATA_REF_KEY) {
 return comp_data_refs(btrfs_delayed_node_to_data_ref(ref2),

[ 132/136 ] tracing: Fix ftrace_dump()

Steven Rostedt — 2013-05-18T02:18:09

3.6.11.4 stable review patch.
If anyone has any objections, please let me know.

------------------

From: "Steven Rostedt (Red Hat)" <rostedt< at >goodmis.org>

[ Upstream commit 7fe70b579c9e3daba71635e31b6189394e7b79d3 ]

ftrace_dump() had a lot of issues. What ftrace_dump() does, is when
ftrace_dump_on_oops is set (via a kernel parameter or sysctl), it
will dump out the ftrace buffers to the console when either a oops,
panic, or a sysrq-z occurs.

This was written a long time ago when ftrace was fragile to recursion.
But it wasn't written well even for that.

There's a possible deadlock that can occur if a ftrace_dump() is happening
and an NMI triggers another dump. This is because it grabs a lock
before checking if the dump ran.

It also totally disables ftrace, and tracing for no good reasons.

As the ring_buffer now checks if it is read via a oops or NMI, where
there's a chance that the buffer gets corrupted, it will disable
itself. No need to have ftrace_dump() do the same.

ftrace_dump() is now cleaned up where it uses an atomic counter to
make sure only one dump happens at a time. A simple atomic_inc_return()
is enough that is needed for both other CPUs and NMIs. No need for
a spinlock, as if one CPU is running the dump, no other CPU needs
to do it too.

The tracing_on variable is turned off and not turned on. The original
code did this, but it wasn't pretty. By just disabling this variable
we get the result of not seeing traces that happen between crashes.

For sysrq-z, it doesn't get turned on, but the user can always write
a '1' to the tracing_on file. If they are using sysrq-z, then they should
know about tracing_on.

The new code is much easier to read and less error prone. No more
deadlock possibility when an NMI triggers here.

Reported-by: zhangwei(Jovi) <jovi.zhangwei< at >huawei.com>
Cc: stable< at >vger.kernel.org
Cc: Thomas Gleixner <tglx< at >linutronix.de>
Cc: Peter Zijlstra <a.p.zijlstra< at >chello.nl>
Cc: Frederic Weisbecker <fweisbec< at >gmail.com>
Signed-off-by: Steven Rostedt <rostedt< at >goodmis.org>
---
 kernel/trace/trace.c          |   62 +++++++++++++++++------------------------
 kernel/trace/trace_selftest.c |    9 +++---
 2 files changed, 31 insertions(+), 40 deletions(-)

diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 4a568ba..6fbd63a 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
< at >< at > -4986,36 +4986,32 < at >< at > void trace_init_global_iter(struct trace_iterator *iter)
 iter->cpu_file = TRACE_PIPE_ALL_CPU;
 }
 
-static void
-__ftrace_dump(bool disable_tracing, enum ftrace_dump_mode oops_dump_mode)
+void ftrace_dump(enum ftrace_dump_mode oops_dump_mode)
 {
-static arch_spinlock_t ftrace_dump_lock =
-(arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;
 /* use static because iter can be a bit big for the stack */
 static struct trace_iterator iter;
+static atomic_t dump_running;
 unsigned int old_userobj;
-static int dump_ran;
 unsigned long flags;
 int cnt = 0, cpu;
 
-/* only one dump */
-local_irq_save(flags);
-arch_spin_lock(&ftrace_dump_lock);
-if (dump_ran)
-goto out;
-
-dump_ran = 1;
+/* Only allow one dump user at a time. */
+if (atomic_inc_return(&dump_running) != 1) {
+atomic_dec(&dump_running);
+return;
+}
 
+/*
+ * Always turn off tracing when we dump.
+ * We don't need to show trace output of what happens
+ * between multiple crashes.
+ *
+ * If the user does a sysrq-z, then they can re-enable
+ * tracing with echo 1 > tracing_on.
+ */
 tracing_off();
 
-/* Did function tracer already get disabled? */
-if (ftrace_is_dead()) {
-printk("# WARNING: FUNCTION TRACING IS CORRUPTED\n");
-printk("#          MAY BE MISSING FUNCTION EVENTS\n");
-}
-
-if (disable_tracing)
-ftrace_kill();
+local_irq_save(flags);
 
 trace_init_global_iter(&iter);
 
< at >< at > -5048,6 +5044,12 < at >< at > __ftrace_dump(bool disable_tracing, enum ftrace_dump_mode oops_dump_mode)
 
 printk(KERN_TRACE "Dumping ftrace buffer:\n");
 
+/* Did function tracer already get disabled? */
+if (ftrace_is_dead()) {
+printk("# WARNING: FUNCTION TRACING IS CORRUPTED\n");
+printk("#          MAY BE MISSING FUNCTION EVENTS\n");
+}
+
 /*
  * We need to stop all tracing on all CPUS to read the
  * the next buffer. This is a bit expensive, but is
< at >< at > -5087,26 +5089,14 < at >< at > __ftrace_dump(bool disable_tracing, enum ftrace_dump_mode oops_dump_mode)
 printk(KERN_TRACE "---------------------------------\n");
 
  out_enable:
-/* Re-enable tracing if requested */
-if (!disable_tracing) {
-trace_flags |= old_userobj;
+trace_flags |= old_userobj;
 
-for_each_tracing_cpu(cpu) {
-atomic_dec(&iter.tr->data[cpu]->disabled);
-}
-tracing_on();
+for_each_tracing_cpu(cpu) {
+atomic_dec(&iter.tr->data[cpu]->disabled);
 }
-
- out:
-arch_spin_unlock(&ftrace_dump_lock);
+atomic_dec(&dump_running);
 local_irq_restore(flags);
 }
-
-/* By default: disable tracing after the dump */
-void ftrace_dump(enum ftrace_dump_mode oops_dump_mode)
-{
-__ftrace_dump(true, oops_dump_mode);
-}
 EXPORT_SYMBOL_GPL(ftrace_dump);
 
 __init static int tracer_alloc_buffers(void)
diff --git a/kernel/trace/trace_selftest.c b/kernel/trace/trace_selftest.c
index 288541f..09fd98a 100644
--- a/kernel/trace/trace_selftest.c
+++ b/kernel/trace/trace_selftest.c
< at >< at > -461,8 +461,6 < at >< at > trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
 /* Maximum number of functions to trace before diagnosing a hang */
 #define GRAPH_MAX_FUNC_TEST100000000
 
-static void
-__ftrace_dump(bool disable_tracing, enum ftrace_dump_mode oops_dump_mode);
 static unsigned int graph_hang_thresh;
 
 /* Wrap the real function entry probe to avoid possible hanging */
< at >< at > -472,8 +470,11 < at >< at > static int trace_graph_entry_watchdog(struct ftrace_graph_ent *trace)
 if (unlikely(++graph_hang_thresh > GRAPH_MAX_FUNC_TEST)) {
 ftrace_graph_stop();
 printk(KERN_WARNING "BUG: Function graph tracer hang!\n");
-if (ftrace_dump_on_oops)
-__ftrace_dump(false, DUMP_ALL);
+if (ftrace_dump_on_oops) {
+ftrace_dump(DUMP_ALL);
+/* ftrace_dump() disables tracing */
+tracing_on();
+}
 return 0;
 }

[ 131/136 ] drm/radeon: fix handling of v6 power tables

Steven Rostedt — 2013-05-18T02:18:08

3.6.11.4 stable review patch.
If anyone has any objections, please let me know.

------------------

From: Alex Deucher <alexander.deucher< at >amd.com>

[ Upstream commit 441e76ca83ac604eaf0f046def96d8e3a27eea28 ]

The code was mis-handling variable sized arrays.

Reported-by: Sylvain BERTRAND <sylware< at >legeek.net>
Signed-off-by: Alex Deucher <alexander.deucher< at >amd.com>
Cc: stable< at >vger.kernel.org
Signed-off-by: Steven Rostedt <rostedt< at >goodmis.org>
---
 drivers/gpu/drm/radeon/radeon_atombios.c |   11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/drivers/gpu/drm/radeon/radeon_atombios.c b/drivers/gpu/drm/radeon/radeon_atombios.c
index 77fec04..3e3b3df 100644
--- a/drivers/gpu/drm/radeon/radeon_atombios.c
+++ b/drivers/gpu/drm/radeon/radeon_atombios.c
< at >< at > -2507,6 +2507,7 < at >< at > static int radeon_atombios_parse_power_table_6(struct radeon_device *rdev)
 int index = GetIndexIntoMasterTable(DATA, PowerPlayInfo);
         u16 data_offset;
 u8 frev, crev;
+u8 *power_state_offset;
 
 if (!atom_parse_data_header(mode_info->atom_context, index, NULL,
    &frev, &crev, &data_offset))
< at >< at > -2529,11 +2530,11 < at >< at > static int radeon_atombios_parse_power_table_6(struct radeon_device *rdev)
        state_array->ucNumEntries, GFP_KERNEL);
 if (!rdev->pm.power_state)
 return state_index;
+power_state_offset = (u8 *)state_array->states;
 for (i = 0; i < state_array->ucNumEntries; i++) {
 mode_index = 0;
-power_state = (union pplib_power_state *)&state_array->states[i];
-/* XXX this might be an inagua bug... */
-non_clock_array_index = i; /* power_state->v2.nonClockInfoIndex */
+power_state = (union pplib_power_state *)power_state_offset;
+non_clock_array_index = power_state->v2.nonClockInfoIndex;
 non_clock_info = (struct _ATOM_PPLIB_NONCLOCK_INFO *)
 &non_clock_info_array->nonClockInfo[non_clock_array_index];
 rdev->pm.power_state[i].clock_info = kzalloc(sizeof(struct radeon_pm_clock_info) *
< at >< at > -2545,9 +2546,6 < at >< at > static int radeon_atombios_parse_power_table_6(struct radeon_device *rdev)
 if (power_state->v2.ucNumDPMLevels) {
 for (j = 0; j < power_state->v2.ucNumDPMLevels; j++) {
 clock_array_index = power_state->v2.clockInfoIndex[j];
-/* XXX this might be an inagua bug... */
-if (clock_array_index >= clock_info_array->ucNumEntries)
-continue;
 clock_info = (union pplib_clock_info *)
 &clock_info_array->clockInfo[clock_array_index * clock_info_array->ucEntrySize];
 valid = radeon_atombios_parse_pplib_clock_info(rdev,
< at >< at > -2569,6 +2567,7 < at >< at > static int radeon_atombios_parse_power_table_6(struct radeon_device *rdev)
    non_clock_info);
 state_index++;
 }
+power_state_offset += 2 + power_state->v2.ucNumDPMLevels;
 }
 /* if multiple clock modes, mark the lowest as no display */
 for (i = 0; i < state_index; i++) {

[ 130/136 ] drm/radeon: add new richland pci ids

Steven Rostedt — 2013-05-18T02:18:07

3.6.11.4 stable review patch.
If anyone has any objections, please let me know.

------------------

From: Alex Deucher <alexander.deucher< at >amd.com>

[ Upstream commit 62d1f92e06aef9665d71ca7e986b3047ecf0b3c7 ]

Signed-off-by: Alex Deucher <alexander.deucher< at >amd.com>
Cc: stable< at >vger.kernel.org
Signed-off-by: Steven Rostedt <rostedt< at >goodmis.org>
---
 drivers/gpu/drm/radeon/ni.c |    6 ++++--
 include/drm/drm_pciids.h    |    2 ++
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/drivers/gpu/drm/radeon/ni.c b/drivers/gpu/drm/radeon/ni.c
index 338b71f..62ff39f 100644
--- a/drivers/gpu/drm/radeon/ni.c
+++ b/drivers/gpu/drm/radeon/ni.c
< at >< at > -471,7 +471,8 < at >< at > static void cayman_gpu_init(struct radeon_device *rdev)
     (rdev->pdev->device == 0x990F) ||
     (rdev->pdev->device == 0x9910) ||
     (rdev->pdev->device == 0x9917) ||
-    (rdev->pdev->device == 0x9999)) {
+    (rdev->pdev->device == 0x9999) ||
+    (rdev->pdev->device == 0x999C)) {
 rdev->config.cayman.max_simds_per_se = 6;
 rdev->config.cayman.max_backends_per_se = 2;
 } else if ((rdev->pdev->device == 0x9903) ||
< at >< at > -480,7 +481,8 < at >< at > static void cayman_gpu_init(struct radeon_device *rdev)
    (rdev->pdev->device == 0x990D) ||
    (rdev->pdev->device == 0x990E) ||
    (rdev->pdev->device == 0x9913) ||
-   (rdev->pdev->device == 0x9918)) {
+   (rdev->pdev->device == 0x9918) ||
+   (rdev->pdev->device == 0x999D)) {
 rdev->config.cayman.max_simds_per_se = 4;
 rdev->config.cayman.max_backends_per_se = 2;
 } else if ((rdev->pdev->device == 0x9919) ||
diff --git a/include/drm/drm_pciids.h b/include/drm/drm_pciids.h
index 36e5b94..d7da55c 100644
--- a/include/drm/drm_pciids.h
+++ b/include/drm/drm_pciids.h
< at >< at > -593,6 +593,8 < at >< at >
 {0x1002, 0x9999, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_ARUBA|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
 {0x1002, 0x999A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_ARUBA|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
 {0x1002, 0x999B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_ARUBA|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
+{0x1002, 0x999C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_ARUBA|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
+{0x1002, 0x999D, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_ARUBA|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
 {0x1002, 0x99A0, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_ARUBA|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
 {0x1002, 0x99A2, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_ARUBA|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
 {0x1002, 0x99A4, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_ARUBA|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \

[ 127/136 ] drm/radeon: fix typo in si_select_se_sh()

Steven Rostedt — 2013-05-18T02:18:04

3.6.11.4 stable review patch.
If anyone has any objections, please let me know.

------------------

From: Alex Deucher <alexander.deucher< at >amd.com>

[ Upstream commit 79b52d6a7085a3e430c6de450a5847fdbe04159b ]

Signed-off-by: Alex Deucher <alexander.deucher< at >amd.com>
Cc: stable< at >vger.kernel.org
Signed-off-by: Steven Rostedt <rostedt< at >goodmis.org>
---
 drivers/gpu/drm/radeon/si.c |    2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/drivers/gpu/drm/radeon/si.c b/drivers/gpu/drm/radeon/si.c
index 992e60c..f2b256c 100644
--- a/drivers/gpu/drm/radeon/si.c
+++ b/drivers/gpu/drm/radeon/si.c
< at >< at > -1374,7 +1374,7 < at >< at > static void si_select_se_sh(struct radeon_device *rdev,
 u32 data = INSTANCE_BROADCAST_WRITES;
 
 if ((se_num == 0xffffffff) && (sh_num == 0xffffffff))
-data = SH_BROADCAST_WRITES | SE_BROADCAST_WRITES;
+data |= SH_BROADCAST_WRITES | SE_BROADCAST_WRITES;
 else if (se_num == 0xffffffff)
 data |= SE_BROADCAST_WRITES | SH_INDEX(sh_num);
 else if (sh_num == 0xffffffff)

[ 124/136 ] drm/radeon/evergreen+: dont enable HPD interrupts on eDP/LVDS

Steven Rostedt — 2013-05-18T02:18:01

3.6.11.4 stable review patch.
If anyone has any objections, please let me know.

------------------

From: Alex Deucher <alexander.deucher< at >amd.com>

[ Upstream commit 2e97be73e5f74a317232740ae82eb8f95326a660 ]

Avoids potential interrupt storms when the display is disabled.

May fix:
https://bugzilla.kernel.org/show_bug.cgi?id=56041

Signed-off-by: Alex Deucher <alexander.deucher< at >amd.com>
Cc: stable< at >vger.kernel.org
Signed-off-by: Steven Rostedt <rostedt< at >goodmis.org>
---
 drivers/gpu/drm/radeon/evergreen.c |   10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/drivers/gpu/drm/radeon/evergreen.c b/drivers/gpu/drm/radeon/evergreen.c
index cbbaaf6..5c23991 100644
--- a/drivers/gpu/drm/radeon/evergreen.c
+++ b/drivers/gpu/drm/radeon/evergreen.c
< at >< at > -569,6 +569,16 < at >< at > void evergreen_hpd_init(struct radeon_device *rdev)
 
 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
+
+if (connector->connector_type == DRM_MODE_CONNECTOR_eDP ||
+    connector->connector_type == DRM_MODE_CONNECTOR_LVDS) {
+/* don't try to enable hpd on eDP or LVDS avoid breaking the
+ * aux dp channel on imac and help (but not completely fix)
+ * https://bugzilla.redhat.com/show_bug.cgi?id=726143
+ * also avoid interrupt storms during dpms.
+ */
+continue;
+}
 switch (radeon_connector->hpd.hpd) {
 case RADEON_HPD_1:
 WREG32(DC_HPD1_CONTROL, tmp);

[ 125/136 ] drm/radeon: cleanup properly if mmio mapping fails

Steven Rostedt — 2013-05-18T02:18:02

3.6.11.4 stable review patch.
If anyone has any objections, please let me know.

------------------

From: Alex Deucher <alexander.deucher< at >amd.com>

[ Upstream commit 0cd9cb76ae26a19df21abc6f94f5fff141e689c7 ]

If we fail to map the mmio BAR, skip driver tear down
that requires mmio.

Should fix:
https://bugzilla.kernel.org/show_bug.cgi?id=56541

Signed-off-by: Alex Deucher <alexander.deucher< at >amd.com>
Cc: stable< at >vger.kernel.org
Signed-off-by: Steven Rostedt <rostedt< at >goodmis.org>
---
 drivers/gpu/drm/radeon/radeon_kms.c |    4 ++++
 1 file changed, 4 insertions(+)

diff --git a/drivers/gpu/drm/radeon/radeon_kms.c b/drivers/gpu/drm/radeon/radeon_kms.c
index 414b4ac..e32f4c2 100644
--- a/drivers/gpu/drm/radeon/radeon_kms.c
+++ b/drivers/gpu/drm/radeon/radeon_kms.c
< at >< at > -51,8 +51,12 < at >< at > int radeon_driver_unload_kms(struct drm_device *dev)
 
 if (rdev == NULL)
 return 0;
+if (rdev->rmmio == NULL)
+goto done_free;
 radeon_modeset_fini(rdev);
 radeon_device_fini(rdev);
+
+done_free:
 kfree(rdev);
 dev->dev_private = NULL;
 return 0;

[ 126/136 ] drm/radeon: fix hdmi mode enable on RS600/RS690/RS740

Steven Rostedt — 2013-05-18T02:18:03

3.6.11.4 stable review patch.
If anyone has any objections, please let me know.

------------------

From: Alex Deucher <alexander.deucher< at >amd.com>

[ Upstream commit dcb852905772416e322536ced5cb3c796d176af5 ]

These chips were previously skipped since they are
pre-R600.

Signed-off-by: Alex Deucher <alexander.deucher< at >amd.com>
Cc: stable< at >vger.kernel.org
Signed-off-by: Steven Rostedt <rostedt< at >goodmis.org>
---
 drivers/gpu/drm/radeon/r600_hdmi.c |    4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/drivers/gpu/drm/radeon/r600_hdmi.c b/drivers/gpu/drm/radeon/r600_hdmi.c
index e3558c3..ecf263f 100644
--- a/drivers/gpu/drm/radeon/r600_hdmi.c
+++ b/drivers/gpu/drm/radeon/r600_hdmi.c
< at >< at > -489,7 +489,7 < at >< at > void r600_hdmi_enable(struct drm_encoder *encoder)
 offset = dig->afmt->offset;
 
 /* Older chipsets require setting HDMI and routing manually */
-if (rdev->family >= CHIP_R600 && !ASIC_IS_DCE3(rdev)) {
+if (ASIC_IS_DCE2(rdev) && !ASIC_IS_DCE3(rdev)) {
 hdmi = HDMI0_ERROR_ACK | HDMI0_ENABLE;
 switch (radeon_encoder->encoder_id) {
 case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_TMDS1:
< at >< at > -558,7 +558,7 < at >< at > void r600_hdmi_disable(struct drm_encoder *encoder)
 radeon_irq_kms_disable_afmt(rdev, dig->afmt->id);
 
 /* Older chipsets not handled by AtomBIOS */
-if (rdev->family >= CHIP_R600 && !ASIC_IS_DCE3(rdev)) {
+if (ASIC_IS_DCE2(rdev) && !ASIC_IS_DCE3(rdev)) {
 switch (radeon_encoder->encoder_id) {
 case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_TMDS1:
 WREG32_P(AVIVO_TMDSA_CNTL, 0,

[ 120/136 ] drm/radeon: update wait_for_vblank for evergreen+

Steven Rostedt — 2013-05-18T02:17:57

3.6.11.4 stable review patch.
If anyone has any objections, please let me know.

------------------

From: Alex Deucher <alexander.deucher< at >amd.com>

[ Upstream commit 10257a6d8359c41407eb26b7ad7bf710a7e00155 ]

Properly wait for the next vblank region.  The previous
code didn't always wait long enough depending on the timing.

Signed-off-by: Alex Deucher <alexander.deucher< at >amd.com>
Cc: stable< at >vger.kernel.org
Signed-off-by: Steven Rostedt <rostedt< at >goodmis.org>
---
 drivers/gpu/drm/radeon/evergreen.c |   44 +++++++++++++++++++++++++++++-------
 1 file changed, 36 insertions(+), 8 deletions(-)

diff --git a/drivers/gpu/drm/radeon/evergreen.c b/drivers/gpu/drm/radeon/evergreen.c
index 5528fea..6cb958b 100644
--- a/drivers/gpu/drm/radeon/evergreen.c
+++ b/drivers/gpu/drm/radeon/evergreen.c
< at >< at > -109,6 +109,27 < at >< at > void evergreen_fix_pci_max_read_req_size(struct radeon_device *rdev)
 }
 }
 
+static bool dce4_is_in_vblank(struct radeon_device *rdev, int crtc)
+{
+if (RREG32(EVERGREEN_CRTC_STATUS + crtc_offsets[crtc]) & EVERGREEN_CRTC_V_BLANK)
+return true;
+else
+return false;
+}
+
+static bool dce4_is_counter_moving(struct radeon_device *rdev, int crtc)
+{
+u32 pos1, pos2;
+
+pos1 = RREG32(EVERGREEN_CRTC_STATUS_POSITION + crtc_offsets[crtc]);
+pos2 = RREG32(EVERGREEN_CRTC_STATUS_POSITION + crtc_offsets[crtc]);
+
+if (pos1 != pos2)
+return true;
+else
+return false;
+}
+
 /**
  * dce4_wait_for_vblank - vblank wait asic callback.
  *
< at >< at > -119,21 +140,28 < at >< at > void evergreen_fix_pci_max_read_req_size(struct radeon_device *rdev)
  */
 void dce4_wait_for_vblank(struct radeon_device *rdev, int crtc)
 {
-int i;
+unsigned i = 0;
 
 if (crtc >= rdev->num_crtc)
 return;
 
-if (RREG32(EVERGREEN_CRTC_CONTROL + crtc_offsets[crtc]) & EVERGREEN_CRTC_MASTER_EN) {
-for (i = 0; i < rdev->usec_timeout; i++) {
-if (!(RREG32(EVERGREEN_CRTC_STATUS + crtc_offsets[crtc]) & EVERGREEN_CRTC_V_BLANK))
+if (!(RREG32(EVERGREEN_CRTC_CONTROL + crtc_offsets[crtc]) & EVERGREEN_CRTC_MASTER_EN))
+return;
+
+/* depending on when we hit vblank, we may be close to active; if so,
+ * wait for another frame.
+ */
+while (dce4_is_in_vblank(rdev, crtc)) {
+if (i++ % 100 == 0) {
+if (!dce4_is_counter_moving(rdev, crtc))
 break;
-udelay(1);
 }
-for (i = 0; i < rdev->usec_timeout; i++) {
-if (RREG32(EVERGREEN_CRTC_STATUS + crtc_offsets[crtc]) & EVERGREEN_CRTC_V_BLANK)
+}
+
+while (!dce4_is_in_vblank(rdev, crtc)) {
+if (i++ % 100 == 0) {
+if (!dce4_is_counter_moving(rdev, crtc))
 break;
-udelay(1);
 }
 }
 }