Revert "ARM: tegra: tegratab: dummy change"
[linux-2.6.git] / drivers / edp / edp.c
1 /*
2  * Copyright (c) 2012-2013, NVIDIA CORPORATION.  All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms and conditions of the GNU General Public License,
6  * version 2, as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope it will be useful, but WITHOUT
9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
11  * more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
15  */
16
17 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/string.h>
20 #include <linux/mutex.h>
21 #include <linux/errno.h>
22 #include <linux/slab.h>
23 #include <linux/edp.h>
24 #include "edp_internal.h"
25
26 DEFINE_MUTEX(edp_lock);
27 static LIST_HEAD(edp_managers);
28 LIST_HEAD(edp_governors);
29
30 static struct edp_manager *find_manager(const char *name)
31 {
32         struct edp_manager *mgr;
33
34         if (!name)
35                 return NULL;
36
37         list_for_each_entry(mgr, &edp_managers, link)
38                 if (!strcmp(mgr->name, name))
39                         return mgr;
40
41         return NULL;
42 }
43
44 static void promote(struct work_struct *work)
45 {
46         unsigned int prev_denied;
47         struct edp_manager *m = container_of(work, struct edp_manager, work);
48
49         mutex_lock(&edp_lock);
50
51         if (m->num_denied && m->remaining && m->gov) {
52                 prev_denied = m->num_denied;
53                 m->gov->promote(m);
54                 if (prev_denied != m->num_denied)
55                         sysfs_notify(m->kobj, NULL, "denied");
56         }
57
58         mutex_unlock(&edp_lock);
59 }
60
61 void schedule_promotion(struct edp_manager *mgr)
62 {
63         if (mgr->remaining && mgr->num_denied && mgr->gov->promote)
64                 schedule_work(&mgr->work);
65 }
66
67 int edp_register_manager(struct edp_manager *mgr)
68 {
69         int r = -EEXIST;
70
71         if (!mgr)
72                 return -EINVAL;
73         if (!mgr->max)
74                 return -EINVAL;
75
76         mutex_lock(&edp_lock);
77         if (!find_manager(mgr->name)) {
78                 list_add_tail(&mgr->link, &edp_managers);
79                 mgr->registered = true;
80                 mgr->remaining = mgr->max;
81                 mgr->gov = NULL;
82                 mgr->gov_data = NULL;
83                 INIT_LIST_HEAD(&mgr->clients);
84                 INIT_WORK(&mgr->work, promote);
85                 mgr->kobj = NULL;
86                 edp_manager_add_kobject(mgr);
87                 manager_add_dentry(mgr);
88                 r = 0;
89         }
90         mutex_unlock(&edp_lock);
91
92         return r;
93 }
94 EXPORT_SYMBOL(edp_register_manager);
95
96 int edp_set_governor_unlocked(struct edp_manager *mgr,
97                 struct edp_governor *gov)
98 {
99         int r = 0;
100
101         if (mgr ? !mgr->registered : 1)
102                 return -EINVAL;
103
104         if (mgr->gov) {
105                 if (mgr->gov->stop)
106                         mgr->gov->stop(mgr);
107                 mgr->gov->refcnt--;
108                 module_put(mgr->gov->owner);
109                 mgr->gov = NULL;
110         }
111
112         if (gov) {
113                 if (!gov->refcnt)
114                         return -EINVAL;
115                 if (!try_module_get(gov->owner))
116                         return -EINVAL;
117                 if (gov->start)
118                         r = gov->start(mgr);
119                 if (r) {
120                         module_put(gov->owner);
121                         WARN_ON(1);
122                         return r;
123                 }
124
125                 gov->refcnt++;
126                 mgr->gov = gov;
127         }
128
129         return 0;
130 }
131
132 int edp_unregister_manager(struct edp_manager *mgr)
133 {
134         if (!mgr)
135                 return -EINVAL;
136
137         mutex_lock(&edp_lock);
138
139         if (!mgr->registered) {
140                 mutex_unlock(&edp_lock);
141                 return -ENODEV;
142         }
143
144         if (!list_empty(&mgr->clients)) {
145                 mutex_unlock(&edp_lock);
146                 return -EBUSY;
147         }
148
149         manager_remove_dentry(mgr);
150         edp_manager_remove_kobject(mgr);
151         edp_set_governor_unlocked(mgr, NULL);
152         list_del(&mgr->link);
153         mgr->registered = false;
154
155         mutex_unlock(&edp_lock);
156         cancel_work_sync(&mgr->work);
157
158         return 0;
159 }
160 EXPORT_SYMBOL(edp_unregister_manager);
161
162 struct edp_manager *edp_get_manager(const char *name)
163 {
164         struct edp_manager *mgr;
165
166         mutex_lock(&edp_lock);
167         mgr = find_manager(name);
168         mutex_unlock(&edp_lock);
169
170         return mgr;
171 }
172 EXPORT_SYMBOL(edp_get_manager);
173
174 static struct edp_client *find_client(struct edp_manager *mgr,
175                 const char *name)
176 {
177         struct edp_client *p;
178
179         if (!name)
180                 return NULL;
181
182         list_for_each_entry(p, &mgr->clients, link)
183                 if (!strcmp(p->name, name))
184                         return p;
185
186         return NULL;
187 }
188
189 unsigned int e0_current_sum(struct edp_manager *mgr)
190 {
191         struct edp_client *p;
192         unsigned int sum = 0;
193
194         list_for_each_entry(p, &mgr->clients, link)
195                 sum += p->states[p->e0_index];
196
197         return sum;
198 }
199
200 static bool states_ok(struct edp_client *client)
201 {
202         int i;
203
204         if (!client->states || !client->num_states ||
205                         client->e0_index >= client->num_states)
206                 return false;
207
208         /* state array should be sorted in descending order */
209         for (i = 1; i < client->num_states; i++)
210                 if (client->states[i] > client->states[i - 1])
211                         return false;
212
213         return client->states[0] ? true : false;
214 }
215
216 /* Keep the list sorted on priority */
217 static void add_client(struct edp_client *new, struct list_head *head)
218 {
219         struct edp_client *p;
220
221         list_for_each_entry(p, head, link) {
222                 if (p->priority > new->priority) {
223                         list_add_tail(&new->link, &p->link);
224                         return;
225                 }
226         }
227
228         list_add_tail(&new->link, &p->link);
229 }
230
231 int register_client(struct edp_manager *mgr, struct edp_client *client)
232 {
233         if (!mgr || !client)
234                 return -EINVAL;
235
236         if (!mgr->registered)
237                 return -ENODEV;
238
239         if (client->manager || find_client(mgr, client->name))
240                 return -EEXIST;
241
242         if (!states_ok(client) || client->priority > EDP_MIN_PRIO ||
243                         client->priority < EDP_MAX_PRIO ||
244                         (client->e0_index && !client->throttle))
245                 return -EINVAL;
246
247         /* make sure that we can satisfy E0 for all registered clients */
248         if (e0_current_sum(mgr) + client->states[client->e0_index] > mgr->max)
249                 return -E2BIG;
250
251         add_client(client, &mgr->clients);
252         client->manager = mgr;
253         client->req = NULL;
254         client->cur = NULL;
255         INIT_LIST_HEAD(&client->borrowers);
256         client->num_borrowers = 0;
257         client->num_loans = 0;
258         client->ithreshold = client->states[0];
259         client->kobj = NULL;
260         edp_client_add_kobject(client);
261         client_add_dentry(client);
262
263         return 0;
264 }
265
266 int edp_register_client(struct edp_manager *mgr, struct edp_client *client)
267 {
268         int r;
269
270         mutex_lock(&edp_lock);
271         r = register_client(mgr, client);
272         mutex_unlock(&edp_lock);
273
274         return r;
275 }
276 EXPORT_SYMBOL(edp_register_client);
277
278 static void update_loans(struct edp_client *client)
279 {
280         struct edp_governor *gov;
281         gov = client->manager ? client->manager->gov : NULL;
282         if (gov && client->cur && !list_empty(&client->borrowers)) {
283                 if (gov->update_loans && *client->cur > client->ithreshold)
284                         gov->update_loans(client);
285         }
286 }
287
288 /* generic default implementation */
289 void edp_default_update_request(struct edp_client *client,
290                 const unsigned int *req,
291                 void (*throttle)(struct edp_client *))
292 {
293         struct edp_manager *m = client->manager;
294         unsigned int old = cur_level(client);
295         unsigned int new = req ? *req : 0;
296         bool was_denied = client->cur != client->req;
297
298         client->req = req;
299
300         if (new < old) {
301                 client->cur = req;
302                 m->remaining += old - new;
303         } else if (new - old <= m->remaining) {
304                 client->cur = req;
305                 m->remaining -= new - old;
306         } else {
307                 throttle(client);
308         }
309
310         if (was_denied && client->cur == client->req)
311                 m->num_denied--;
312         else if (!was_denied && client->cur != client->req)
313                 m->num_denied++;
314 }
315
316 /* generic default implementation */
317 void edp_default_update_loans(struct edp_client *lender)
318 {
319         unsigned int size = *lender->cur - lender->ithreshold;
320         struct loan_client *p;
321
322         list_for_each_entry(p, &lender->borrowers, link) {
323                 if (size != p->size) {
324                         p->size = p->client->notify_loan_update(
325                                 size, lender, p->client->private_data);
326                         WARN_ON(p->size > size);
327                 }
328
329                 size -= min(p->size, size);
330                 if (!size)
331                         return;
332         }
333 }
334
335 unsigned int edp_throttling_point(struct edp_client *c, unsigned int deficit)
336 {
337         unsigned int lim;
338         unsigned int i;
339
340         if (cur_level(c) - e0_level(c) <= deficit)
341                 return c->e0_index;
342
343         lim = cur_level(c) - deficit;
344         i = cur_index(c);
345         while (i < c->e0_index && c->states[i] > lim)
346                 i++;
347
348         return i;
349 }
350
351 unsigned int edp_promotion_point(struct edp_client *c, unsigned int step)
352 {
353         unsigned int limit = cur_level(c) + step;
354         unsigned int ci = cur_index(c);
355         unsigned int i = req_index(c);
356
357         while (i < ci && c->states[i] > limit)
358                 i++;
359
360         WARN_ON(i >= c->num_states);
361         return i;
362 }
363
364 static int mod_request(struct edp_client *client, const unsigned int *req)
365 {
366         struct edp_manager *m = client->manager;
367         unsigned int prev_remain = m->remaining;
368         unsigned int prev_denied = m->num_denied;
369
370         if (!m->gov)
371                 return -ENODEV;
372
373         m->gov->update_request(client, req);
374         update_loans(client);
375
376         /* Do not block calling clients for promotions */
377         if (m->remaining > prev_remain)
378                 schedule_promotion(m);
379
380         if (m->num_denied != prev_denied)
381                 sysfs_notify(m->kobj, NULL, "denied");
382
383         return 0;
384 }
385
386 static void del_borrower(struct edp_client *lender, struct loan_client *pcl)
387 {
388         pcl->client->notify_loan_close(lender, pcl->client->private_data);
389         lender->num_borrowers--;
390         pcl->client->num_loans--;
391         list_del(&pcl->link);
392         kfree(pcl);
393 }
394
395 static void close_all_loans(struct edp_client *client)
396 {
397         struct loan_client *p;
398
399         while (!list_empty(&client->borrowers)) {
400                 p = list_first_entry(&client->borrowers, struct loan_client,
401                                 link);
402                 del_borrower(client, p);
403         }
404 }
405
406 static inline bool registered_client(struct edp_client *client)
407 {
408         return client ? client->manager : false;
409 }
410
411 int unregister_client(struct edp_client *client)
412 {
413         if (!registered_client(client))
414                 return -EINVAL;
415
416         if (client->num_loans)
417                 return -EBUSY;
418
419         client_remove_dentry(client);
420         edp_client_remove_kobject(client);
421         close_all_loans(client);
422         mod_request(client, NULL);
423         list_del(&client->link);
424         client->manager = NULL;
425
426         return 0;
427 }
428
429 int edp_unregister_client(struct edp_client *client)
430 {
431         int r;
432
433         mutex_lock(&edp_lock);
434         r = unregister_client(client);
435         mutex_unlock(&edp_lock);
436
437         return r;
438 }
439 EXPORT_SYMBOL(edp_unregister_client);
440
441 int edp_update_client_request_unlocked(struct edp_client *client,
442                 unsigned int req, int *approved)
443 {
444         int r;
445
446         if (!registered_client(client))
447                 return -EINVAL;
448
449         if (req >= client->num_states)
450                 return -EINVAL;
451
452         r = mod_request(client, client->states + req);
453         if (!r && approved)
454                 *approved = client->cur - client->states;
455
456         return r;
457 }
458
459 int edp_update_client_request(struct edp_client *client, unsigned int req,
460                 unsigned int *approved)
461 {
462         int r;
463
464         mutex_lock(&edp_lock);
465         r = edp_update_client_request_unlocked(client, req, approved);
466         mutex_unlock(&edp_lock);
467
468         return r;
469 }
470 EXPORT_SYMBOL(edp_update_client_request);
471
472 static struct edp_client *get_client(const char *name)
473 {
474         struct edp_client *client;
475         struct edp_manager *mgr;
476
477         if (!name)
478                 return NULL;
479
480         list_for_each_entry(mgr, &edp_managers, link) {
481                 client = find_client(mgr, name);
482                 if (client)
483                         return client;
484         }
485
486         return NULL;
487 }
488
489 struct edp_client *edp_get_client(const char *name)
490 {
491         struct edp_client *client;
492
493         mutex_lock(&edp_lock);
494         client = get_client(name);
495         mutex_unlock(&edp_lock);
496
497         return client;
498 }
499 EXPORT_SYMBOL(edp_get_client);
500
501 static struct loan_client *find_borrower(struct edp_client *lender,
502                 struct edp_client *borrower)
503 {
504         struct loan_client *p;
505
506         list_for_each_entry(p, &lender->borrowers, link)
507                 if (p->client == borrower)
508                         return p;
509         return NULL;
510 }
511
512 /* Keep the list sorted on priority */
513 static void add_borrower(struct loan_client *new, struct list_head *head)
514 {
515         struct loan_client *p;
516
517         list_for_each_entry(p, head, link) {
518                 if (p->client->priority > new->client->priority) {
519                         list_add_tail(&new->link, &p->link);
520                         return;
521                 }
522         }
523
524         list_add_tail(&new->link, &p->link);
525 }
526
527 static int register_loan(struct edp_client *lender, struct edp_client *borrower)
528 {
529         struct loan_client *p;
530
531         if (!registered_client(lender) || !registered_client(borrower))
532                 return -EINVAL;
533
534         if (lender->manager != borrower->manager ||
535                         !borrower->notify_loan_update ||
536                         !borrower->notify_loan_close)
537                 return -EINVAL;
538
539         if (find_borrower(lender, borrower))
540                 return -EEXIST;
541
542         if (lender->num_borrowers >= lender->max_borrowers)
543                 return -EBUSY;
544
545         p = kzalloc(sizeof(*p), GFP_KERNEL);
546         if (!p)
547                 return -ENOMEM;
548
549         p->client = borrower;
550         lender->num_borrowers++;
551         borrower->num_loans++;
552         add_borrower(p, &lender->borrowers);
553
554         update_loans(lender);
555         return 0;
556 }
557
558 int edp_register_loan(struct edp_client *lender, struct edp_client *borrower)
559 {
560         int r;
561
562         mutex_lock(&edp_lock);
563         r = register_loan(lender, borrower);
564         mutex_unlock(&edp_lock);
565
566         return r;
567 }
568 EXPORT_SYMBOL(edp_register_loan);
569
570 static int unregister_loan(struct edp_client *lender,
571                 struct edp_client *borrower)
572 {
573         struct loan_client *p;
574
575         if (!registered_client(lender) || !registered_client(borrower))
576                 return -EINVAL;
577
578         p = find_borrower(lender, borrower);
579         if (!p)
580                 return -EINVAL;
581
582         del_borrower(lender, p);
583         update_loans(lender);
584         return 0;
585 }
586
587 int edp_unregister_loan(struct edp_client *lender, struct edp_client *borrower)
588 {
589         int r;
590
591         mutex_lock(&edp_lock);
592         r = unregister_loan(lender, borrower);
593         mutex_unlock(&edp_lock);
594
595         return r;
596 }
597 EXPORT_SYMBOL(edp_unregister_loan);
598
599 int edp_update_loan_threshold_unlocked(struct edp_client *client,
600                 unsigned int threshold)
601 {
602         if (!registered_client(client))
603                 return -EINVAL;
604
605         client->ithreshold = threshold;
606         update_loans(client);
607         return 0;
608 }
609
610 int edp_update_loan_threshold(struct edp_client *client, unsigned int threshold)
611 {
612         int r;
613
614         mutex_lock(&edp_lock);
615         r = edp_update_loan_threshold_unlocked(client, threshold);
616         mutex_unlock(&edp_lock);
617
618         return r;
619 }
620 EXPORT_SYMBOL(edp_update_loan_threshold);
621
622 struct edp_governor *edp_find_governor_unlocked(const char *s)
623 {
624         struct edp_governor *g;
625
626         list_for_each_entry(g, &edp_governors, link)
627                 if (!strnicmp(s, g->name, EDP_NAME_LEN))
628                         return g;
629
630         return NULL;
631 }
632
633 int edp_register_governor(struct edp_governor *gov)
634 {
635         int r = 0;
636
637         if (!gov)
638                 return -EINVAL;
639
640         if (!gov->update_request)
641                 return -EINVAL;
642
643         mutex_lock(&edp_lock);
644         if (edp_find_governor_unlocked(gov->name)) {
645                 r = -EEXIST;
646         } else {
647                 gov->refcnt = 1;
648                 list_add(&gov->link, &edp_governors);
649         }
650         mutex_unlock(&edp_lock);
651
652         return r;
653 }
654 EXPORT_SYMBOL(edp_register_governor);
655
656 int edp_unregister_governor(struct edp_governor *gov)
657 {
658         int r = 0;
659
660         mutex_lock(&edp_lock);
661         if (!gov) {
662                 r = -EINVAL;
663         } else if (gov->refcnt != 1) {
664                 r = gov->refcnt > 1 ? -EBUSY : -ENODEV;
665         } else {
666                 list_del(&gov->link);
667                 gov->refcnt = 0;
668         }
669         mutex_unlock(&edp_lock);
670
671         return r;
672 }
673 EXPORT_SYMBOL(edp_unregister_governor);
674
675 struct edp_governor *edp_get_governor(const char *name)
676 {
677         struct edp_governor *g;
678
679         mutex_lock(&edp_lock);
680         g = edp_find_governor_unlocked(name);
681         mutex_unlock(&edp_lock);
682
683         return g;
684 }
685 EXPORT_SYMBOL(edp_get_governor);
686
687 int edp_set_governor(struct edp_manager *mgr, struct edp_governor *gov)
688 {
689         int r;
690
691         mutex_lock(&edp_lock);
692         r = edp_set_governor_unlocked(mgr, gov);
693         mutex_unlock(&edp_lock);
694
695         return r;
696 }
697 EXPORT_SYMBOL(edp_set_governor);