LXR linux/drivers/hwmon/pmbus/ucd9200.c

   1/*
   2 * Hardware monitoring driver for ucd9200 series Digital PWM System Controllers
   3 *
   4 * Copyright (C) 2011 Ericsson AB.
   5 *
   6 * This program is free software; you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License as published by
   8 * the Free Software Foundation; either version 2 of the License, or
   9 * (at your option) any later version.
  10 *
  11 * This program is distributed in the hope that it will be useful,
  12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14 * GNU General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU General Public License
  17 * along with this program; if not, write to the Free Software
  18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21#include <linux/kernel.h>
  22#include <linux/module.h>
  23#include <linux/init.h>
  24#include <linux/err.h>
  25#include <linux/slab.h>
  26#include <linux/i2c.h>
  27#include <linux/i2c/pmbus.h>
  28#include "pmbus.h"
  29
  30#define UCD9200_PHASE_INFO      0xd2
  31#define UCD9200_DEVICE_ID       0xfd
  32
  33enum chips { ucd9200, ucd9220, ucd9222, ucd9224, ucd9240, ucd9244, ucd9246,
  34             ucd9248 };
  35
  36static const struct i2c_device_id ucd9200_id[] = {
  37        {"ucd9200", ucd9200},
  38        {"ucd9220", ucd9220},
  39        {"ucd9222", ucd9222},
  40        {"ucd9224", ucd9224},
  41        {"ucd9240", ucd9240},
  42        {"ucd9244", ucd9244},
  43        {"ucd9246", ucd9246},
  44        {"ucd9248", ucd9248},
  45        {}
  46};
  47MODULE_DEVICE_TABLE(i2c, ucd9200_id);
  48
  49static int ucd9200_probe(struct i2c_client *client,
  50                         const struct i2c_device_id *id)
  51{
  52        u8 block_buffer[I2C_SMBUS_BLOCK_MAX + 1];
  53        struct pmbus_driver_info *info;
  54        const struct i2c_device_id *mid;
  55        int i, j, ret;
  56
  57        if (!i2c_check_functionality(client->adapter,
  58                                     I2C_FUNC_SMBUS_BYTE_DATA |
  59                                     I2C_FUNC_SMBUS_BLOCK_DATA))
  60                return -ENODEV;
  61
  62        ret = i2c_smbus_read_block_data(client, UCD9200_DEVICE_ID,
  63                                        block_buffer);
  64        if (ret < 0) {
  65                dev_err(&client->dev, "Failed to read device ID\n");
  66                return ret;
  67        }
  68        block_buffer[ret] = '\0';
  69        dev_info(&client->dev, "Device ID %s\n", block_buffer);
  70
  71        for (mid = ucd9200_id; mid->name[0]; mid++) {
  72                if (!strncasecmp(mid->name, block_buffer, strlen(mid->name)))
  73                        break;
  74        }
  75        if (!mid->name[0]) {
  76                dev_err(&client->dev, "Unsupported device\n");
  77                return -ENODEV;
  78        }
  79        if (id->driver_data != ucd9200 && id->driver_data != mid->driver_data)
  80                dev_notice(&client->dev,
  81                           "Device mismatch: Configured %s, detected %s\n",
  82                           id->name, mid->name);
  83
  84        info = devm_kzalloc(&client->dev, sizeof(struct pmbus_driver_info),
  85                            GFP_KERNEL);
  86        if (!info)
  87                return -ENOMEM;
  88
  89        ret = i2c_smbus_read_block_data(client, UCD9200_PHASE_INFO,
  90                                        block_buffer);
  91        if (ret < 0) {
  92                dev_err(&client->dev, "Failed to read phase information\n");
  93                return ret;
  94        }
  95
  96        /*
  97         * Calculate number of configured pages (rails) from PHASE_INFO
  98         * register.
  99         * Rails have to be sequential, so we can abort after finding
 100         * the first unconfigured rail.
 101         */
 102        info->pages = 0;
 103        for (i = 0; i < ret; i++) {
 104                if (!block_buffer[i])
 105                        break;
 106                info->pages++;
 107        }
 108        if (!info->pages) {
 109                dev_err(&client->dev, "No rails configured\n");
 110                return -ENODEV;
 111        }
 112        dev_info(&client->dev, "%d rails configured\n", info->pages);
 113
 114        /*
 115         * Set PHASE registers on all pages to 0xff to ensure that phase
 116         * specific commands will apply to all phases of a given page (rail).
 117         * This only affects the READ_IOUT and READ_TEMPERATURE2 registers.
 118         * READ_IOUT will return the sum of currents of all phases of a rail,
 119         * and READ_TEMPERATURE2 will return the maximum temperature detected
 120         * for the the phases of the rail.
 121         */
 122        for (i = 0; i < info->pages; i++) {
 123                /*
 124                 * Setting PAGE & PHASE fails once in a while for no obvious
 125                 * reason, so we need to retry a couple of times.
 126                 */
 127                for (j = 0; j < 3; j++) {
 128                        ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, i);
 129                        if (ret < 0)
 130                                continue;
 131                        ret = i2c_smbus_write_byte_data(client, PMBUS_PHASE,
 132                                                        0xff);
 133                        if (ret < 0)
 134                                continue;
 135                        break;
 136                }
 137                if (ret < 0) {
 138                        dev_err(&client->dev,
 139                                "Failed to initialize PHASE registers\n");
 140                        return ret;
 141                }
 142        }
 143        if (info->pages > 1)
 144                i2c_smbus_write_byte_data(client, PMBUS_PAGE, 0);
 145
 146        info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT |
 147                        PMBUS_HAVE_IIN | PMBUS_HAVE_PIN |
 148                        PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT |
 149                        PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT |
 150                        PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP |
 151                        PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
 152
 153        for (i = 1; i < info->pages; i++)
 154                info->func[i] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT |
 155                        PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT |
 156                        PMBUS_HAVE_POUT |
 157                        PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
 158
 159        /* ucd9240 supports a single fan */
 160        if (mid->driver_data == ucd9240)
 161                info->func[0] |= PMBUS_HAVE_FAN12 | PMBUS_HAVE_STATUS_FAN12;
 162
 163        return pmbus_do_probe(client, mid, info);
 164}
 165
 166/* This is the driver that will be inserted */
 167static struct i2c_driver ucd9200_driver = {
 168        .driver = {
 169                .name = "ucd9200",
 170        },
 171        .probe = ucd9200_probe,
 172        .remove = pmbus_do_remove,
 173        .id_table = ucd9200_id,
 174};
 175
 176module_i2c_driver(ucd9200_driver);
 177
 178MODULE_AUTHOR("Guenter Roeck");
 179MODULE_DESCRIPTION("PMBus driver for TI UCD922x, UCD924x");
 180MODULE_LICENSE("GPL");
 181