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 */
configure_channel(struct most_interface * most_iface,int ch_idx,struct most_channel_config * channel_config)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 */
enqueue(struct most_interface * most_iface,int ch_idx,struct mbo * mbo)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 */
poison_channel(struct most_interface * most_iface,int ch_idx)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
request_netinfo(struct most_interface * most_iface,int ch_idx)188 static void request_netinfo(struct most_interface *most_iface,
189 int ch_idx)
190 {
191 pr_info("request_netinfo()\n");
192 }
193
do_rx_work(struct hdm_i2c * dev)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 */
pending_rx_work(struct work_struct * work)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 */
most_irq_handler(int irq,void * _dev)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 */
i2c_probe(struct i2c_client * client,const struct i2c_device_id * id)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 */
i2c_remove(struct i2c_client * client)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");
431