tree fa99cfa8b0e261a673f208e44a140e3ee933b612
parent b5527a7766f0505dc72efe3cefe5e9dea826f611
author Jean Delvare <khali@linux-fr.org> 1267529023 +0100
committer Jean Delvare <khali@linux-fr.org> 1267529023 +0100

i2c: Separate Kconfig option for i2c-smbus

Having a separate Kconfig option for i2c-smbus makes it possible to
build that support as a module even when i2c-core itself is built-in.
Bus drivers which implement SMBus alert should select this option, so
in most cases this option is hidden and the user doesn't have to care
about it.

Signed-off-by: Jean Delvare <khali@linux-fr.org>
Cc: David Brownell <dbrownell@users.sourceforge.net>
Cc: Trent Piepho <tpiepho@freescale.com>
