tree 54f6084a69dc8a0d10c475438da086f1b56298b4
parent e2ee3616bc334ab51e68aad6905761ca97f35559
author Randy Dunlap <randy.dunlap@oracle.com> 1245344117 -0700
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1245600179 -0500

cnic: add NETDEV_1000 and NETDEVICES to Kconfig select

NETDEVICES + NETDEV_1000 need to be enabled so that kconfig will check
those branches for selects and enforce "select UIO" under CNIC.
Otherwise the build fails with:

ERROR: "uio_unregister_device" [drivers/net/cnic.ko] undefined!
ERROR: "uio_event_notify" [drivers/net/cnic.ko] undefined!
ERROR: "__uio_register_device" [drivers/net/cnic.ko] undefined!

Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Acked-by: Michael Chan <mchan@broadcom.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
