drivers/staging/most/hdm-i2c/hdm_i2c.c

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