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

Commit 22cdbd1d authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6 

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6: (108 commits)
  ehea: Fixing statistics
  bonding: Fix lockdep warning after bond_vlan_rx_register()
  tunnels: Fix tunnels change rcu protection
  caif-u5500: Build config for CAIF shared mem driver
  caif-u5500: CAIF shared memory mailbox interface
  caif-u5500: CAIF shared memory transport protocol
  caif-u5500: Adding shared memory include
  drivers/isdn: delete double assignment
  drivers/net/typhoon.c: delete double assignment
  drivers/net/sb1000.c: delete double assignment
  qlcnic: define valid vlan id range
  qlcnic: reduce rx ring size
  qlcnic: fix mac learning
  ehea: fix use after free
  inetpeer: __rcu annotations
  fib_rules: __rcu annotates ctarget
  tunnels: add __rcu annotations
  net: add __rcu annotations to protocol
  ipv4: add __rcu annotations to routes.c
  qlge: bugfix: Restoring the vlan setting.
  ...
parents 55f335a8 ce45b873

Documentation/networking/phy.txt

+0 −18
Original line number Diff line number Diff line
@@ -177,18 +177,6 @@ Doing it all yourself 
 

   A convenience function to print out the PHY status neatly.



 int phy_clear_interrupt(struct phy_device *phydev);

 int phy_config_interrupt(struct phy_device *phydev, u32 interrupts);

   

   Clear the PHY's interrupt, and configure which ones are allowed,

   respectively.  Currently only supports all on, or all off.

 

 int phy_enable_interrupts(struct phy_device *phydev);

 int phy_disable_interrupts(struct phy_device *phydev);



   Functions which enable/disable PHY interrupts, clearing them

   before and after, respectively.



 int phy_start_interrupts(struct phy_device *phydev);

 int phy_stop_interrupts(struct phy_device *phydev);
@@ -213,12 +201,6 @@ Doing it all yourself 
   Fills the phydev structure with up-to-date information about the current

   settings in the PHY.



 void phy_sanitize_settings(struct phy_device *phydev)

   

   Resolves differences between currently desired settings, and

   supported settings for the given PHY device.  Does not make

   the changes in the hardware, though.



 int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd);

 int phy_ethtool_gset(struct phy_device *phydev, struct ethtool_cmd *cmd);

drivers/atm/eni.c

+4 −3
Original line number Diff line number Diff line
@@ -1736,9 +1736,10 @@ static int __devinit eni_do_init(struct atm_dev *dev) 
		eprom = (base+EPROM_SIZE-sizeof(struct midway_eprom));

		if (readl(&eprom->magic) != ENI155_MAGIC) {

			printk("\n");

			printk(KERN_ERR KERN_ERR DEV_LABEL "(itf %d): bad "

			    "magic - expected 0x%x, got 0x%x\n",dev->number,

			    ENI155_MAGIC,(unsigned) readl(&eprom->magic));

			printk(KERN_ERR DEV_LABEL

			       "(itf %d): bad magic - expected 0x%x, got 0x%x\n",

			       dev->number, ENI155_MAGIC,

			       (unsigned)readl(&eprom->magic));

			error = -EINVAL;

			goto unmap;

		}

drivers/connector/cn_queue.c

+8 −67
Original line number Diff line number Diff line
@@ -31,48 +31,6 @@ 
#include <linux/connector.h>

#include <linux/delay.h>





/*

 * This job is sent to the kevent workqueue.

 * While no event is once sent to any callback, the connector workqueue

 * is not created to avoid a useless waiting kernel task.

 * Once the first event is received, we create this dedicated workqueue which

 * is necessary because the flow of data can be high and we don't want

 * to encumber keventd with that.

 */

static void cn_queue_create(struct work_struct *work)

{

	struct cn_queue_dev *dev;



	dev = container_of(work, struct cn_queue_dev, wq_creation);



	dev->cn_queue = create_singlethread_workqueue(dev->name);

	/* If we fail, we will use keventd for all following connector jobs */

	WARN_ON(!dev->cn_queue);

}



/*

 * Queue a data sent to a callback.

 * If the connector workqueue is already created, we queue the job on it.

 * Otherwise, we queue the job to kevent and queue the connector workqueue

 * creation too.

 */

int queue_cn_work(struct cn_callback_entry *cbq, struct work_struct *work)

{

	struct cn_queue_dev *pdev = cbq->pdev;



	if (likely(pdev->cn_queue))

		return queue_work(pdev->cn_queue, work);



	/* Don't create the connector workqueue twice */

	if (atomic_inc_return(&pdev->wq_requested) == 1)

		schedule_work(&pdev->wq_creation);

	else

		atomic_dec(&pdev->wq_requested);



	return schedule_work(work);

}



void cn_queue_wrapper(struct work_struct *work)

{

	struct cn_callback_entry *cbq =
@@ -111,11 +69,7 @@ cn_queue_alloc_callback_entry(char *name, struct cb_id *id, 


static void cn_queue_free_callback(struct cn_callback_entry *cbq)

{

	/* The first jobs have been sent to kevent, flush them too */

	flush_scheduled_work();

	if (cbq->pdev->cn_queue)

	flush_workqueue(cbq->pdev->cn_queue);



	kfree(cbq);

}
@@ -193,11 +147,14 @@ struct cn_queue_dev *cn_queue_alloc_dev(char *name, struct sock *nls) 
	atomic_set(&dev->refcnt, 0);

	INIT_LIST_HEAD(&dev->queue_list);

	spin_lock_init(&dev->queue_lock);

	init_waitqueue_head(&dev->wq_created);



	dev->nls = nls;



	INIT_WORK(&dev->wq_creation, cn_queue_create);

	dev->cn_queue = alloc_ordered_workqueue(dev->name, 0);

	if (!dev->cn_queue) {

		kfree(dev);

		return NULL;

	}



	return dev;

}
@@ -205,25 +162,9 @@ struct cn_queue_dev *cn_queue_alloc_dev(char *name, struct sock *nls) 
void cn_queue_free_dev(struct cn_queue_dev *dev)

{

	struct cn_callback_entry *cbq, *n;

	long timeout;

	DEFINE_WAIT(wait);



	/* Flush the first pending jobs queued on kevent */

	flush_scheduled_work();



	/* If the connector workqueue creation is still pending, wait for it */

	prepare_to_wait(&dev->wq_created, &wait, TASK_UNINTERRUPTIBLE);

	if (atomic_read(&dev->wq_requested) && !dev->cn_queue) {

		timeout = schedule_timeout(HZ * 2);

		if (!timeout && !dev->cn_queue)

			WARN_ON(1);

	}

	finish_wait(&dev->wq_created, &wait);



	if (dev->cn_queue) {

	flush_workqueue(dev->cn_queue);

	destroy_workqueue(dev->cn_queue);

	}



	spin_lock_bh(&dev->queue_lock);

	list_for_each_entry_safe(cbq, n, &dev->queue_list, callback_entry)

drivers/connector/connector.c

+4 −5
Original line number Diff line number Diff line
@@ -133,7 +133,8 @@ static int cn_call_callback(struct sk_buff *skb) 
					__cbq->data.skb == NULL)) {

				__cbq->data.skb = skb;



				if (queue_cn_work(__cbq, &__cbq->work))

				if (queue_work(dev->cbdev->cn_queue,

					       &__cbq->work))

					err = 0;

				else

					err = -EINVAL;
@@ -148,12 +149,10 @@ static int cn_call_callback(struct sk_buff *skb) 
					d->callback = __cbq->data.callback;

					d->free = __new_cbq;



					__new_cbq->pdev = __cbq->pdev;



					INIT_WORK(&__new_cbq->work,

							&cn_queue_wrapper);



					if (queue_cn_work(__new_cbq,

					if (queue_work(dev->cbdev->cn_queue,

						       &__new_cbq->work))

						err = 0;

					else {

drivers/isdn/hardware/mISDN/mISDNinfineon.c

+1 −1
Original line number Diff line number Diff line
@@ -563,7 +563,7 @@ reset_inf(struct inf_hw *hw) 
		mdelay(10);

		hw->ipac.isac.adf2 = 0x87;

		hw->ipac.hscx[0].slot = 0x1f;

		hw->ipac.hscx[0].slot = 0x23;

		hw->ipac.hscx[1].slot = 0x23;

		break;

	case INF_GAZEL_R753:

		val = inl((u32)hw->cfg.start + GAZEL_CNTRL);