drivers/staging/most/i2c/i2c.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * i2c.c - Hardware Dependent Module for I2C Interface
   4  *
   5  * Copyright (C) 2013-2015, Microchip Technology Germany II GmbH & Co. KG
   6  */
   7
   8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   9
  10 #include <linux/init.h>
  11 #include <linux/module.h>
  12 #include <linux/slab.h>
  13 #include <linux/i2c.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/err.h>
  16
  17 #include "most/core.h"
  18
  19 enum { CH_RX, CH_TX, NUM_CHANNELS };
  20
  21 #define MAX_BUFFERS_CONTROL 32
  22 #define MAX_BUF_SIZE_CONTROL 256
  23
  24 /**
  25  * list_first_mbo - get the first mbo from a list
  26  * @ptr:        the list head to take the mbo from.
  27  */
  28 #define list_first_mbo(ptr) \
  29         list_first_entry(ptr, struct mbo, list)
  30
  31 static unsigned int polling_rate;
  32 module_param(polling_rate, uint, 0644);
  33 MODULE_PARM_DESC(polling_rate, "Polling rate [Hz]. Default = 0 (use IRQ)");
  34
  35 struct hdm_i2c {
  36         struct most_interface most_iface;
  37         struct most_channel_capability capabilities[NUM_CHANNELS];
  38         struct i2c_client *client;
  39         struct rx {
  40                 struct delayed_work dwork;
  41                 struct list_head list;
  42                 bool int_disabled;
  43                 unsigned int delay;
  44         } rx;
  45         char name[64];
  46 };
  47
  48 #define to_hdm(iface) container_of(iface, struct hdm_i2c, most_iface)
  49
  50 static irqreturn_t most_irq_handler(int, void *);
  51 static void pending_rx_work(struct work_struct *);
  52
  53 /**
  54  * configure_channel - called from MOST core to configure a channel
  55  * @iface: interface the channel belongs to
  56  * @channel: channel to be configured
  57  * @channel_config: structure that holds the configuration information
  58  *
  59  * Return 0 on success, negative on failure.
  60  *
  61  * Receives configuration information from MOST core and initialize the
  62  * corresponding channel.
  63  */
  64 static int configure_channel(struct most_interface *most_iface,
  65                              int ch_idx,
  66                              struct most_channel_config *channel_config)
  67 {
  68         int ret;
  69         struct hdm_i2c *dev = to_hdm(most_iface);
  70         unsigned int delay, pr;
  71
  72         BUG_ON(ch_idx < 0 || ch_idx >= NUM_CHANNELS);
  73
  74         if (channel_config->data_type != MOST_CH_CONTROL) {
  75                 pr_err("bad data type for channel %d\n", ch_idx);
  76                 return -EPERM;
  77         }
  78
  79         if (channel_config->direction != dev->capabilities[ch_idx].direction) {
  80                 pr_err("bad direction for channel %d\n", ch_idx);
  81                 return -EPERM;
  82         }
  83
  84         if (channel_config->direction == MOST_CH_RX) {
  85                 if (!polling_rate) {
  86                         if (dev->client->irq <= 0) {
  87                                 pr_err("bad irq: %d\n", dev->client->irq);
  88                                 return -ENOENT;
  89                         }
  90                         dev->rx.int_disabled = false;
  91                         ret = request_irq(dev->client->irq, most_irq_handler, 0,
  92                                           dev->client->name, dev);
  93                         if (ret) {
  94                                 pr_err("request_irq(%d) failed: %d\n",
  95                                        dev->client->irq, ret);
  96                                 return ret;
  97                         }
  98                 } else {
  99                         delay = msecs_to_jiffies(MSEC_PER_SEC / polling_rate);
 100                         dev->rx.delay = delay ? delay : 1;
 101                         pr = MSEC_PER_SEC / jiffies_to_msecs(dev->rx.delay);
 102                         pr_info("polling rate is %u Hz\n", pr);
 103                 }
 104         }
 105
 106         return 0;
 107 }
 108
 109 /**
 110  * enqueue - called from MOST core to enqueue a buffer for data transfer
 111  * @iface: intended interface
 112  * @channel: ID of the channel the buffer is intended for
 113  * @mbo: pointer to the buffer object
 114  *
 115  * Return 0 on success, negative on failure.
 116  *
 117  * Transmit the data over I2C if it is a "write" request or push the buffer into
 118  * list if it is an "read" request
 119  */
 120 static int enqueue(struct most_interface *most_iface,
 121                    int ch_idx, struct mbo *mbo)
 122 {
 123         struct hdm_i2c *dev = to_hdm(most_iface);
 124         int ret;
 125
 126         BUG_ON(ch_idx < 0 || ch_idx >= NUM_CHANNELS);
 127
 128         if (ch_idx == CH_RX) {
 129                 /* RX */
 130                 if (!polling_rate)
 131                         disable_irq(dev->client->irq);
 132                 cancel_delayed_work_sync(&dev->rx.dwork);
 133                 list_add_tail(&mbo->list, &dev->rx.list);
 134                 if (dev->rx.int_disabled || polling_rate)
 135                         pending_rx_work(&dev->rx.dwork.work);
 136                 if (!polling_rate)
 137                         enable_irq(dev->client->irq);
 138         } else {
 139                 /* TX */
 140                 ret = i2c_master_send(dev->client, mbo->virt_address,
 141                                       mbo->buffer_length);
 142                 if (ret <= 0) {
 143                         mbo->processed_length = 0;
 144                         mbo->status = MBO_E_INVAL;
 145                 } else {
 146                         mbo->processed_length = mbo->buffer_length;
 147                         mbo->status = MBO_SUCCESS;
 148                 }
 149                 mbo->complete(mbo);
 150         }
 151
 152         return 0;
 153 }
 154
 155 /**
 156  * poison_channel - called from MOST core to poison buffers of a channel
 157  * @iface: pointer to the interface the channel to be poisoned belongs to
 158  * @channel_id: corresponding channel ID
 159  *
 160  * Return 0 on success, negative on failure.
 161  *
 162  * If channel direction is RX, complete the buffers in list with
 163  * status MBO_E_CLOSE
 164  */
 165 static int poison_channel(struct most_interface *most_iface,
 166                           int ch_idx)
 167 {
 168         struct hdm_i2c *dev = to_hdm(most_iface);
 169         struct mbo *mbo;
 170
 171         BUG_ON(ch_idx < 0 || ch_idx >= NUM_CHANNELS);
 172
 173         if (ch_idx == CH_RX) {
 174                 if (!polling_rate)
 175                         free_irq(dev->client->irq, dev);
 176                 cancel_delayed_work_sync(&dev->rx.dwork);
 177
 178                 while (!list_empty(&dev->rx.list)) {
 179                         mbo = list_first_mbo(&dev->rx.list);
 180                         list_del(&mbo->list);
 181
 182                         mbo->processed_length = 0;
 183                         mbo->status = MBO_E_CLOSE;
 184                         mbo->complete(mbo);
 185                 }
 186         }
 187
 188         return 0;
 189 }
 190
 191 static void do_rx_work(struct hdm_i2c *dev)
 192 {
 193         struct mbo *mbo;
 194         unsigned char msg[MAX_BUF_SIZE_CONTROL];
 195         int ret;
 196         u16 pml, data_size;
 197
 198         /* Read PML (2 bytes) */
 199         ret = i2c_master_recv(dev->client, msg, 2);
 200         if (ret <= 0) {
 201                 pr_err("Failed to receive PML\n");
 202                 return;
 203         }
 204
 205         pml = (msg[0] << 8) | msg[1];
 206         if (!pml)
 207                 return;
 208
 209         data_size = pml + 2;
 210
 211         /* Read the whole message, including PML */
 212         ret = i2c_master_recv(dev->client, msg, data_size);
 213         if (ret <= 0) {
 214                 pr_err("Failed to receive a Port Message\n");
 215                 return;
 216         }
 217
 218         mbo = list_first_mbo(&dev->rx.list);
 219         list_del(&mbo->list);
 220
 221         mbo->processed_length = min(data_size, mbo->buffer_length);
 222         memcpy(mbo->virt_address, msg, mbo->processed_length);
 223         mbo->status = MBO_SUCCESS;
 224         mbo->complete(mbo);
 225 }
 226
 227 /**
 228  * pending_rx_work - Read pending messages through I2C
 229  * @work: definition of this work item
 230  *
 231  * Invoked by the Interrupt Service Routine, most_irq_handler()
 232  */
 233 static void pending_rx_work(struct work_struct *work)
 234 {
 235         struct hdm_i2c *dev = container_of(work, struct hdm_i2c, rx.dwork.work);
 236
 237         if (list_empty(&dev->rx.list))
 238                 return;
 239
 240         do_rx_work(dev);
 241
 242         if (polling_rate) {
 243                 schedule_delayed_work(&dev->rx.dwork, dev->rx.delay);
 244         } else {
 245                 dev->rx.int_disabled = false;
 246                 enable_irq(dev->client->irq);
 247         }
 248 }
 249
 250 /*
 251  * most_irq_handler - Interrupt Service Routine
 252  * @irq: irq number
 253  * @_dev: private data
 254  *
 255  * Schedules a delayed work
 256  *
 257  * By default the interrupt line behavior is Active Low. Once an interrupt is
 258  * generated by the device, until driver clears the interrupt (by reading
 259  * the PMP message), device keeps the interrupt line in low state. Since i2c
 260  * read is done in work queue, the interrupt line must be disabled temporarily
 261  * to avoid ISR being called repeatedly. Re-enable the interrupt in workqueue,
 262  * after reading the message.
 263  *
 264  * Note: If we use the interrupt line in Falling edge mode, there is a
 265  * possibility to miss interrupts when ISR is getting executed.
 266  *
 267  */
 268 static irqreturn_t most_irq_handler(int irq, void *_dev)
 269 {
 270         struct hdm_i2c *dev = _dev;
 271
 272         disable_irq_nosync(irq);
 273         dev->rx.int_disabled = true;
 274         schedule_delayed_work(&dev->rx.dwork, 0);
 275
 276         return IRQ_HANDLED;
 277 }
 278
 279 /*
 280  * i2c_probe - i2c probe handler
 281  * @client: i2c client device structure
 282  * @id: i2c client device id
 283  *
 284  * Return 0 on success, negative on failure.
 285  *
 286  * Register the i2c client device as a MOST interface
 287  */
 288 static int i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
 289 {
 290         struct hdm_i2c *dev;
 291         int ret, i;
 292
 293         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 294         if (!dev)
 295                 return -ENOMEM;
 296
 297         /* ID format: i2c-<bus>-<address> */
 298         snprintf(dev->name, sizeof(dev->name), "i2c-%d-%04x",
 299                  client->adapter->nr, client->addr);
 300
 301         for (i = 0; i < NUM_CHANNELS; i++) {
 302                 dev->capabilities[i].data_type = MOST_CH_CONTROL;
 303                 dev->capabilities[i].num_buffers_packet = MAX_BUFFERS_CONTROL;
 304                 dev->capabilities[i].buffer_size_packet = MAX_BUF_SIZE_CONTROL;
 305         }
 306         dev->capabilities[CH_RX].direction = MOST_CH_RX;
 307         dev->capabilities[CH_RX].name_suffix = "rx";
 308         dev->capabilities[CH_TX].direction = MOST_CH_TX;
 309         dev->capabilities[CH_TX].name_suffix = "tx";
 310
 311         dev->most_iface.interface = ITYPE_I2C;
 312         dev->most_iface.description = dev->name;
 313         dev->most_iface.num_channels = NUM_CHANNELS;
 314         dev->most_iface.channel_vector = dev->capabilities;
 315         dev->most_iface.configure = configure_channel;
 316         dev->most_iface.enqueue = enqueue;
 317         dev->most_iface.poison_channel = poison_channel;
 318
 319         INIT_LIST_HEAD(&dev->rx.list);
 320
 321         INIT_DELAYED_WORK(&dev->rx.dwork, pending_rx_work);
 322
 323         dev->client = client;
 324         i2c_set_clientdata(client, dev);
 325
 326         ret = most_register_interface(&dev->most_iface);
 327         if (ret) {
 328                 pr_err("Failed to register i2c as a MOST interface\n");
 329                 kfree(dev);
 330                 return ret;
 331         }
 332
 333         return 0;
 334 }
 335
 336 /*
 337  * i2c_remove - i2c remove handler
 338  * @client: i2c client device structure
 339  *
 340  * Return 0 on success.
 341  *
 342  * Unregister the i2c client device as a MOST interface
 343  */
 344 static int i2c_remove(struct i2c_client *client)
 345 {
 346         struct hdm_i2c *dev = i2c_get_clientdata(client);
 347
 348         most_deregister_interface(&dev->most_iface);
 349         kfree(dev);
 350
 351         return 0;
 352 }
 353
 354 static const struct i2c_device_id i2c_id[] = {
 355         { "most_i2c", 0 },
 356         { }, /* Terminating entry */
 357 };
 358
 359 MODULE_DEVICE_TABLE(i2c, i2c_id);
 360
 361 static struct i2c_driver i2c_driver = {
 362         .driver = {
 363                 .name = "hdm_i2c",
 364         },
 365         .probe = i2c_probe,
 366         .remove = i2c_remove,
 367         .id_table = i2c_id,
 368 };
 369
 370 module_i2c_driver(i2c_driver);
 371
 372 MODULE_AUTHOR("Andrey Shvetsov <andrey.shvetsov@k2l.de>");
 373 MODULE_DESCRIPTION("I2C Hardware Dependent Module");
 374 MODULE_LICENSE("GPL");