drivers/bus/ts-nbus.c

   1 /*
   2  * NBUS driver for TS-4600 based boards
   3  *
   4  * Copyright (c) 2016 - Savoir-faire Linux
   5  * Author: Sebastien Bourdelin <sebastien.bourdelin@savoirfairelinux.com>
   6  *
   7  * This file is licensed under the terms of the GNU General Public
   8  * License version 2. This program is licensed "as is" without any
   9  * warranty of any kind, whether express or implied.
  10  *
  11  * This driver implements a GPIOs bit-banged bus, called the NBUS by Technologic
  12  * Systems. It is used to communicate with the peripherals in the FPGA on the
  13  * TS-4600 SoM.
  14  */
  15
  16 #include <linux/bitops.h>
  17 #include <linux/gpio/consumer.h>
  18 #include <linux/kernel.h>
  19 #include <linux/module.h>
  20 #include <linux/mutex.h>
  21 #include <linux/of_platform.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/pwm.h>
  24 #include <linux/ts-nbus.h>
  25
  26 #define TS_NBUS_DIRECTION_IN  0
  27 #define TS_NBUS_DIRECTION_OUT 1
  28 #define TS_NBUS_WRITE_ADR 0
  29 #define TS_NBUS_WRITE_VAL 1
  30
  31 struct ts_nbus {
  32         struct pwm_device *pwm;
  33         struct gpio_descs *data;
  34         struct gpio_desc *csn;
  35         struct gpio_desc *txrx;
  36         struct gpio_desc *strobe;
  37         struct gpio_desc *ale;
  38         struct gpio_desc *rdy;
  39         struct mutex lock;
  40 };
  41
  42 /*
  43  * request all gpios required by the bus.
  44  */
  45 static int ts_nbus_init_pdata(struct platform_device *pdev, struct ts_nbus
  46                 *ts_nbus)
  47 {
  48         ts_nbus->data = devm_gpiod_get_array(&pdev->dev, "ts,data",
  49                         GPIOD_OUT_HIGH);
  50         if (IS_ERR(ts_nbus->data)) {
  51                 dev_err(&pdev->dev, "failed to retrieve ts,data-gpio from dts\n");
  52                 return PTR_ERR(ts_nbus->data);
  53         }
  54
  55         ts_nbus->csn = devm_gpiod_get(&pdev->dev, "ts,csn", GPIOD_OUT_HIGH);
  56         if (IS_ERR(ts_nbus->csn)) {
  57                 dev_err(&pdev->dev, "failed to retrieve ts,csn-gpio from dts\n");
  58                 return PTR_ERR(ts_nbus->csn);
  59         }
  60
  61         ts_nbus->txrx = devm_gpiod_get(&pdev->dev, "ts,txrx", GPIOD_OUT_HIGH);
  62         if (IS_ERR(ts_nbus->txrx)) {
  63                 dev_err(&pdev->dev, "failed to retrieve ts,txrx-gpio from dts\n");
  64                 return PTR_ERR(ts_nbus->txrx);
  65         }
  66
  67         ts_nbus->strobe = devm_gpiod_get(&pdev->dev, "ts,strobe", GPIOD_OUT_HIGH);
  68         if (IS_ERR(ts_nbus->strobe)) {
  69                 dev_err(&pdev->dev, "failed to retrieve ts,strobe-gpio from dts\n");
  70                 return PTR_ERR(ts_nbus->strobe);
  71         }
  72
  73         ts_nbus->ale = devm_gpiod_get(&pdev->dev, "ts,ale", GPIOD_OUT_HIGH);
  74         if (IS_ERR(ts_nbus->ale)) {
  75                 dev_err(&pdev->dev, "failed to retrieve ts,ale-gpio from dts\n");
  76                 return PTR_ERR(ts_nbus->ale);
  77         }
  78
  79         ts_nbus->rdy = devm_gpiod_get(&pdev->dev, "ts,rdy", GPIOD_IN);
  80         if (IS_ERR(ts_nbus->rdy)) {
  81                 dev_err(&pdev->dev, "failed to retrieve ts,rdy-gpio from dts\n");
  82                 return PTR_ERR(ts_nbus->rdy);
  83         }
  84
  85         return 0;
  86 }
  87
  88 /*
  89  * the data gpios are used for reading and writing values, their directions
  90  * should be adjusted accordingly.
  91  */
  92 static void ts_nbus_set_direction(struct ts_nbus *ts_nbus, int direction)
  93 {
  94         int i;
  95
  96         for (i = 0; i < 8; i++) {
  97                 if (direction == TS_NBUS_DIRECTION_IN)
  98                         gpiod_direction_input(ts_nbus->data->desc[i]);
  99                 else
 100                         /* when used as output the default state of the data
 101                          * lines are set to high */
 102                         gpiod_direction_output(ts_nbus->data->desc[i], 1);
 103         }
 104 }
 105
 106 /*
 107  * reset the bus in its initial state.
 108  * The data, csn, strobe and ale lines must be zero'ed to let the FPGA knows a
 109  * new transaction can be process.
 110  */
 111 static void ts_nbus_reset_bus(struct ts_nbus *ts_nbus)
 112 {
 113         int i;
 114         int values[8];
 115
 116         for (i = 0; i < 8; i++)
 117                 values[i] = 0;
 118
 119         gpiod_set_array_value_cansleep(8, ts_nbus->data->desc, values);
 120         gpiod_set_value_cansleep(ts_nbus->csn, 0);
 121         gpiod_set_value_cansleep(ts_nbus->strobe, 0);
 122         gpiod_set_value_cansleep(ts_nbus->ale, 0);
 123 }
 124
 125 /*
 126  * let the FPGA knows it can process.
 127  */
 128 static void ts_nbus_start_transaction(struct ts_nbus *ts_nbus)
 129 {
 130         gpiod_set_value_cansleep(ts_nbus->strobe, 1);
 131 }
 132
 133 /*
 134  * read a byte value from the data gpios.
 135  * return 0 on success or negative errno on failure.
 136  */
 137 static int ts_nbus_read_byte(struct ts_nbus *ts_nbus, u8 *val)
 138 {
 139         struct gpio_descs *gpios = ts_nbus->data;
 140         int ret, i;
 141
 142         *val = 0;
 143         for (i = 0; i < 8; i++) {
 144                 ret = gpiod_get_value_cansleep(gpios->desc[i]);
 145                 if (ret < 0)
 146                         return ret;
 147                 if (ret)
 148                         *val |= BIT(i);
 149         }
 150
 151         return 0;
 152 }
 153
 154 /*
 155  * set the data gpios accordingly to the byte value.
 156  */
 157 static void ts_nbus_write_byte(struct ts_nbus *ts_nbus, u8 byte)
 158 {
 159         struct gpio_descs *gpios = ts_nbus->data;
 160         int i;
 161         int values[8];
 162
 163         for (i = 0; i < 8; i++)
 164                 if (byte & BIT(i))
 165                         values[i] = 1;
 166                 else
 167                         values[i] = 0;
 168
 169         gpiod_set_array_value_cansleep(8, gpios->desc, values);
 170 }
 171
 172 /*
 173  * reading the bus consists of resetting the bus, then notifying the FPGA to
 174  * send the data in the data gpios and return the read value.
 175  * return 0 on success or negative errno on failure.
 176  */
 177 static int ts_nbus_read_bus(struct ts_nbus *ts_nbus, u8 *val)
 178 {
 179         ts_nbus_reset_bus(ts_nbus);
 180         ts_nbus_start_transaction(ts_nbus);
 181
 182         return ts_nbus_read_byte(ts_nbus, val);
 183 }
 184
 185 /*
 186  * writing to the bus consists of resetting the bus, then define the type of
 187  * command (address/value), write the data and notify the FPGA to retrieve the
 188  * value in the data gpios.
 189  */
 190 static void ts_nbus_write_bus(struct ts_nbus *ts_nbus, int cmd, u8 val)
 191 {
 192         ts_nbus_reset_bus(ts_nbus);
 193
 194         if (cmd == TS_NBUS_WRITE_ADR)
 195                 gpiod_set_value_cansleep(ts_nbus->ale, 1);
 196
 197         ts_nbus_write_byte(ts_nbus, val);
 198         ts_nbus_start_transaction(ts_nbus);
 199 }
 200
 201 /*
 202  * read the value in the FPGA register at the given address.
 203  * return 0 on success or negative errno on failure.
 204  */
 205 int ts_nbus_read(struct ts_nbus *ts_nbus, u8 adr, u16 *val)
 206 {
 207         int ret, i;
 208         u8 byte;
 209
 210         /* bus access must be atomic */
 211         mutex_lock(&ts_nbus->lock);
 212
 213         /* set the bus in read mode */
 214         gpiod_set_value_cansleep(ts_nbus->txrx, 0);
 215
 216         /* write address */
 217         ts_nbus_write_bus(ts_nbus, TS_NBUS_WRITE_ADR, adr);
 218
 219         /* set the data gpios direction as input before reading */
 220         ts_nbus_set_direction(ts_nbus, TS_NBUS_DIRECTION_IN);
 221
 222         /* reading value MSB first */
 223         do {
 224                 *val = 0;
 225                 byte = 0;
 226                 for (i = 1; i >= 0; i--) {
 227                         /* read a byte from the bus, leave on error */
 228                         ret = ts_nbus_read_bus(ts_nbus, &byte);
 229                         if (ret < 0)
 230                                 goto err;
 231
 232                         /* append the byte read to the final value */
 233                         *val |= byte << (i * 8);
 234                 }
 235                 gpiod_set_value_cansleep(ts_nbus->csn, 1);
 236                 ret = gpiod_get_value_cansleep(ts_nbus->rdy);
 237         } while (ret);
 238
 239 err:
 240         /* restore the data gpios direction as output after reading */
 241         ts_nbus_set_direction(ts_nbus, TS_NBUS_DIRECTION_OUT);
 242
 243         mutex_unlock(&ts_nbus->lock);
 244
 245         return ret;
 246 }
 247 EXPORT_SYMBOL_GPL(ts_nbus_read);
 248
 249 /*
 250  * write the desired value in the FPGA register at the given address.
 251  */
 252 int ts_nbus_write(struct ts_nbus *ts_nbus, u8 adr, u16 val)
 253 {
 254         int i;
 255
 256         /* bus access must be atomic */
 257         mutex_lock(&ts_nbus->lock);
 258
 259         /* set the bus in write mode */
 260         gpiod_set_value_cansleep(ts_nbus->txrx, 1);
 261
 262         /* write address */
 263         ts_nbus_write_bus(ts_nbus, TS_NBUS_WRITE_ADR, adr);
 264
 265         /* writing value MSB first */
 266         for (i = 1; i >= 0; i--)
 267                 ts_nbus_write_bus(ts_nbus, TS_NBUS_WRITE_VAL, (u8)(val >> (i * 8)));
 268
 269         /* wait for completion */
 270         gpiod_set_value_cansleep(ts_nbus->csn, 1);
 271         while (gpiod_get_value_cansleep(ts_nbus->rdy) != 0) {
 272                 gpiod_set_value_cansleep(ts_nbus->csn, 0);
 273                 gpiod_set_value_cansleep(ts_nbus->csn, 1);
 274         }
 275
 276         mutex_unlock(&ts_nbus->lock);
 277
 278         return 0;
 279 }
 280 EXPORT_SYMBOL_GPL(ts_nbus_write);
 281
 282 static int ts_nbus_probe(struct platform_device *pdev)
 283 {
 284         struct pwm_device *pwm;
 285         struct pwm_args pargs;
 286         struct device *dev = &pdev->dev;
 287         struct ts_nbus *ts_nbus;
 288         int ret;
 289
 290         ts_nbus = devm_kzalloc(dev, sizeof(*ts_nbus), GFP_KERNEL);
 291         if (!ts_nbus)
 292                 return -ENOMEM;
 293
 294         mutex_init(&ts_nbus->lock);
 295
 296         ret = ts_nbus_init_pdata(pdev, ts_nbus);
 297         if (ret < 0)
 298                 return ret;
 299
 300         pwm = devm_pwm_get(dev, NULL);
 301         if (IS_ERR(pwm)) {
 302                 ret = PTR_ERR(pwm);
 303                 if (ret != -EPROBE_DEFER)
 304                         dev_err(dev, "unable to request PWM\n");
 305                 return ret;
 306         }
 307
 308         pwm_get_args(pwm, &pargs);
 309         if (!pargs.period) {
 310                 dev_err(&pdev->dev, "invalid PWM period\n");
 311                 return -EINVAL;
 312         }
 313
 314         /*
 315          * FIXME: pwm_apply_args() should be removed when switching to
 316          * the atomic PWM API.
 317          */
 318         pwm_apply_args(pwm);
 319         ret = pwm_config(pwm, pargs.period, pargs.period);
 320         if (ret < 0)
 321                 return ret;
 322
 323         /*
 324          * we can now start the FPGA and populate the peripherals.
 325          */
 326         pwm_enable(pwm);
 327         ts_nbus->pwm = pwm;
 328
 329         /*
 330          * let the child nodes retrieve this instance of the ts-nbus.
 331          */
 332         dev_set_drvdata(dev, ts_nbus);
 333
 334         ret = of_platform_populate(dev->of_node, NULL, NULL, dev);
 335         if (ret < 0)
 336                 return ret;
 337
 338         dev_info(dev, "initialized\n");
 339
 340         return 0;
 341 }
 342
 343 static int ts_nbus_remove(struct platform_device *pdev)
 344 {
 345         struct ts_nbus *ts_nbus = dev_get_drvdata(&pdev->dev);
 346
 347         /* shutdown the FPGA */
 348         mutex_lock(&ts_nbus->lock);
 349         pwm_disable(ts_nbus->pwm);
 350         mutex_unlock(&ts_nbus->lock);
 351
 352         return 0;
 353 }
 354
 355 static const struct of_device_id ts_nbus_of_match[] = {
 356         { .compatible = "technologic,ts-nbus", },
 357         { },
 358 };
 359 MODULE_DEVICE_TABLE(of, ts_nbus_of_match);
 360
 361 static struct platform_driver ts_nbus_driver = {
 362         .probe          = ts_nbus_probe,
 363         .remove         = ts_nbus_remove,
 364         .driver         = {
 365                 .name   = "ts_nbus",
 366                 .of_match_table = ts_nbus_of_match,
 367         },
 368 };
 369
 370 module_platform_driver(ts_nbus_driver);
 371
 372 MODULE_ALIAS("platform:ts_nbus");
 373 MODULE_AUTHOR("Sebastien Bourdelin <sebastien.bourdelin@savoirfairelinux.com>");
 374 MODULE_DESCRIPTION("Technologic Systems NBUS");
 375 MODULE_LICENSE("GPL v2");