net/caif: Use pr_fmt
[linux-3.10.git] / net / caif / cfcnfg.c
1 /*
2  * Copyright (C) ST-Ericsson AB 2010
3  * Author:      Sjur Brendeland/sjur.brandeland@stericsson.com
4  * License terms: GNU General Public License (GPL) version 2
5  */
6
7 #define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__
8
9 #include <linux/kernel.h>
10 #include <linux/stddef.h>
11 #include <linux/slab.h>
12 #include <linux/netdevice.h>
13 #include <net/caif/caif_layer.h>
14 #include <net/caif/cfpkt.h>
15 #include <net/caif/cfcnfg.h>
16 #include <net/caif/cfctrl.h>
17 #include <net/caif/cfmuxl.h>
18 #include <net/caif/cffrml.h>
19 #include <net/caif/cfserl.h>
20 #include <net/caif/cfsrvl.h>
21
22 #include <linux/module.h>
23 #include <asm/atomic.h>
24
25 #define MAX_PHY_LAYERS 7
26 #define PHY_NAME_LEN 20
27
28 #define container_obj(layr) container_of(layr, struct cfcnfg, layer)
29 #define RFM_FRAGMENT_SIZE 4030
30
31 /* Information about CAIF physical interfaces held by Config Module in order
32  * to manage physical interfaces
33  */
34 struct cfcnfg_phyinfo {
35         /* Pointer to the layer below the MUX (framing layer) */
36         struct cflayer *frm_layer;
37         /* Pointer to the lowest actual physical layer */
38         struct cflayer *phy_layer;
39         /* Unique identifier of the physical interface */
40         unsigned int id;
41         /* Preference of the physical in interface */
42         enum cfcnfg_phy_preference pref;
43
44         /* Reference count, number of channels using the device */
45         int phy_ref_count;
46
47         /* Information about the physical device */
48         struct dev_info dev_info;
49
50         /* Interface index */
51         int ifindex;
52
53         /* Use Start of frame extension */
54         bool use_stx;
55
56         /* Use Start of frame checksum */
57         bool use_fcs;
58 };
59
60 struct cfcnfg {
61         struct cflayer layer;
62         struct cflayer *ctrl;
63         struct cflayer *mux;
64         u8 last_phyid;
65         struct cfcnfg_phyinfo phy_layers[MAX_PHY_LAYERS];
66 };
67
68 static void cfcnfg_linkup_rsp(struct cflayer *layer, u8 channel_id,
69                              enum cfctrl_srv serv, u8 phyid,
70                              struct cflayer *adapt_layer);
71 static void cfcnfg_linkdestroy_rsp(struct cflayer *layer, u8 channel_id);
72 static void cfcnfg_reject_rsp(struct cflayer *layer, u8 channel_id,
73                              struct cflayer *adapt_layer);
74 static void cfctrl_resp_func(void);
75 static void cfctrl_enum_resp(void);
76
77 struct cfcnfg *cfcnfg_create(void)
78 {
79         struct cfcnfg *this;
80         struct cfctrl_rsp *resp;
81         /* Initiate this layer */
82         this = kzalloc(sizeof(struct cfcnfg), GFP_ATOMIC);
83         if (!this) {
84                 pr_warn("Out of memory\n");
85                 return NULL;
86         }
87         this->mux = cfmuxl_create();
88         if (!this->mux)
89                 goto out_of_mem;
90         this->ctrl = cfctrl_create();
91         if (!this->ctrl)
92                 goto out_of_mem;
93         /* Initiate response functions */
94         resp = cfctrl_get_respfuncs(this->ctrl);
95         resp->enum_rsp = cfctrl_enum_resp;
96         resp->linkerror_ind = cfctrl_resp_func;
97         resp->linkdestroy_rsp = cfcnfg_linkdestroy_rsp;
98         resp->sleep_rsp = cfctrl_resp_func;
99         resp->wake_rsp = cfctrl_resp_func;
100         resp->restart_rsp = cfctrl_resp_func;
101         resp->radioset_rsp = cfctrl_resp_func;
102         resp->linksetup_rsp = cfcnfg_linkup_rsp;
103         resp->reject_rsp = cfcnfg_reject_rsp;
104
105         this->last_phyid = 1;
106
107         cfmuxl_set_uplayer(this->mux, this->ctrl, 0);
108         layer_set_dn(this->ctrl, this->mux);
109         layer_set_up(this->ctrl, this);
110         return this;
111 out_of_mem:
112         pr_warn("Out of memory\n");
113         kfree(this->mux);
114         kfree(this->ctrl);
115         kfree(this);
116         return NULL;
117 }
118 EXPORT_SYMBOL(cfcnfg_create);
119
120 void cfcnfg_remove(struct cfcnfg *cfg)
121 {
122         if (cfg) {
123                 kfree(cfg->mux);
124                 kfree(cfg->ctrl);
125                 kfree(cfg);
126         }
127 }
128
129 static void cfctrl_resp_func(void)
130 {
131 }
132
133 static void cfctrl_enum_resp(void)
134 {
135 }
136
137 struct dev_info *cfcnfg_get_phyid(struct cfcnfg *cnfg,
138                                   enum cfcnfg_phy_preference phy_pref)
139 {
140         u16 i;
141
142         /* Try to match with specified preference */
143         for (i = 1; i < MAX_PHY_LAYERS; i++) {
144                 if (cnfg->phy_layers[i].id == i &&
145                      cnfg->phy_layers[i].pref == phy_pref &&
146                      cnfg->phy_layers[i].frm_layer != NULL) {
147                         caif_assert(cnfg->phy_layers != NULL);
148                         caif_assert(cnfg->phy_layers[i].id == i);
149                         return &cnfg->phy_layers[i].dev_info;
150                 }
151         }
152         /* Otherwise just return something */
153         for (i = 1; i < MAX_PHY_LAYERS; i++) {
154                 if (cnfg->phy_layers[i].id == i) {
155                         caif_assert(cnfg->phy_layers != NULL);
156                         caif_assert(cnfg->phy_layers[i].id == i);
157                         return &cnfg->phy_layers[i].dev_info;
158                 }
159         }
160
161         return NULL;
162 }
163
164 static struct cfcnfg_phyinfo *cfcnfg_get_phyinfo(struct cfcnfg *cnfg,
165                                                         u8 phyid)
166 {
167         int i;
168         /* Try to match with specified preference */
169         for (i = 0; i < MAX_PHY_LAYERS; i++)
170                 if (cnfg->phy_layers[i].frm_layer != NULL &&
171                     cnfg->phy_layers[i].id == phyid)
172                         return &cnfg->phy_layers[i];
173         return NULL;
174 }
175
176 int cfcnfg_get_named(struct cfcnfg *cnfg, char *name)
177 {
178         int i;
179
180         /* Try to match with specified name */
181         for (i = 0; i < MAX_PHY_LAYERS; i++) {
182                 if (cnfg->phy_layers[i].frm_layer != NULL
183                     && strcmp(cnfg->phy_layers[i].phy_layer->name,
184                               name) == 0)
185                         return cnfg->phy_layers[i].frm_layer->id;
186         }
187         return 0;
188 }
189
190 int cfcnfg_disconn_adapt_layer(struct cfcnfg *cnfg, struct cflayer *adap_layer)
191 {
192         u8 channel_id = 0;
193         int ret = 0;
194         struct cflayer *servl = NULL;
195         struct cfcnfg_phyinfo *phyinfo = NULL;
196         u8 phyid = 0;
197         caif_assert(adap_layer != NULL);
198         channel_id = adap_layer->id;
199         if (adap_layer->dn == NULL || channel_id == 0) {
200                 pr_err("adap_layer->id is 0\n");
201                 ret = -ENOTCONN;
202                 goto end;
203         }
204         servl = cfmuxl_remove_uplayer(cnfg->mux, channel_id);
205         if (servl == NULL)
206                 goto end;
207         layer_set_up(servl, NULL);
208         ret = cfctrl_linkdown_req(cnfg->ctrl, channel_id, adap_layer);
209         if (servl == NULL) {
210                 pr_err("PROTOCOL ERROR - Error removing service_layer Channel_Id(%d)",
211                        channel_id);
212                 ret = -EINVAL;
213                 goto end;
214         }
215         caif_assert(channel_id == servl->id);
216         if (adap_layer->dn != NULL) {
217                 phyid = cfsrvl_getphyid(adap_layer->dn);
218
219                 phyinfo = cfcnfg_get_phyinfo(cnfg, phyid);
220                 if (phyinfo == NULL) {
221                         pr_warn("No interface to send disconnect to\n");
222                         ret = -ENODEV;
223                         goto end;
224                 }
225                 if (phyinfo->id != phyid ||
226                         phyinfo->phy_layer->id != phyid ||
227                         phyinfo->frm_layer->id != phyid) {
228                         pr_err("Inconsistency in phy registration\n");
229                         ret = -EINVAL;
230                         goto end;
231                 }
232         }
233         if (phyinfo != NULL && --phyinfo->phy_ref_count == 0 &&
234                 phyinfo->phy_layer != NULL &&
235                 phyinfo->phy_layer->modemcmd != NULL) {
236                 phyinfo->phy_layer->modemcmd(phyinfo->phy_layer,
237                                              _CAIF_MODEMCMD_PHYIF_USELESS);
238         }
239 end:
240         cfsrvl_put(servl);
241         cfctrl_cancel_req(cnfg->ctrl, adap_layer);
242         if (adap_layer->ctrlcmd != NULL)
243                 adap_layer->ctrlcmd(adap_layer, CAIF_CTRLCMD_DEINIT_RSP, 0);
244         return ret;
245
246 }
247 EXPORT_SYMBOL(cfcnfg_disconn_adapt_layer);
248
249 void cfcnfg_release_adap_layer(struct cflayer *adap_layer)
250 {
251         if (adap_layer->dn)
252                 cfsrvl_put(adap_layer->dn);
253 }
254 EXPORT_SYMBOL(cfcnfg_release_adap_layer);
255
256 static void cfcnfg_linkdestroy_rsp(struct cflayer *layer, u8 channel_id)
257 {
258 }
259
260 int protohead[CFCTRL_SRV_MASK] = {
261         [CFCTRL_SRV_VEI] = 4,
262         [CFCTRL_SRV_DATAGRAM] = 7,
263         [CFCTRL_SRV_UTIL] = 4,
264         [CFCTRL_SRV_RFM] = 3,
265         [CFCTRL_SRV_DBG] = 3,
266 };
267
268 int cfcnfg_add_adaptation_layer(struct cfcnfg *cnfg,
269                                 struct cfctrl_link_param *param,
270                                 struct cflayer *adap_layer,
271                                 int *ifindex,
272                                 int *proto_head,
273                                 int *proto_tail)
274 {
275         struct cflayer *frml;
276         if (adap_layer == NULL) {
277                 pr_err("adap_layer is zero\n");
278                 return -EINVAL;
279         }
280         if (adap_layer->receive == NULL) {
281                 pr_err("adap_layer->receive is NULL\n");
282                 return -EINVAL;
283         }
284         if (adap_layer->ctrlcmd == NULL) {
285                 pr_err("adap_layer->ctrlcmd == NULL\n");
286                 return -EINVAL;
287         }
288         frml = cnfg->phy_layers[param->phyid].frm_layer;
289         if (frml == NULL) {
290                 pr_err("Specified PHY type does not exist!\n");
291                 return -ENODEV;
292         }
293         caif_assert(param->phyid == cnfg->phy_layers[param->phyid].id);
294         caif_assert(cnfg->phy_layers[param->phyid].frm_layer->id ==
295                      param->phyid);
296         caif_assert(cnfg->phy_layers[param->phyid].phy_layer->id ==
297                      param->phyid);
298
299         *ifindex = cnfg->phy_layers[param->phyid].ifindex;
300         *proto_head =
301                 protohead[param->linktype]+
302                 (cnfg->phy_layers[param->phyid].use_stx ? 1 : 0);
303
304         *proto_tail = 2;
305
306         /* FIXME: ENUMERATE INITIALLY WHEN ACTIVATING PHYSICAL INTERFACE */
307         cfctrl_enum_req(cnfg->ctrl, param->phyid);
308         return cfctrl_linkup_request(cnfg->ctrl, param, adap_layer);
309 }
310 EXPORT_SYMBOL(cfcnfg_add_adaptation_layer);
311
312 static void cfcnfg_reject_rsp(struct cflayer *layer, u8 channel_id,
313                              struct cflayer *adapt_layer)
314 {
315         if (adapt_layer != NULL && adapt_layer->ctrlcmd != NULL)
316                 adapt_layer->ctrlcmd(adapt_layer,
317                                      CAIF_CTRLCMD_INIT_FAIL_RSP, 0);
318 }
319
320 static void
321 cfcnfg_linkup_rsp(struct cflayer *layer, u8 channel_id, enum cfctrl_srv serv,
322                  u8 phyid, struct cflayer *adapt_layer)
323 {
324         struct cfcnfg *cnfg = container_obj(layer);
325         struct cflayer *servicel = NULL;
326         struct cfcnfg_phyinfo *phyinfo;
327         struct net_device *netdev;
328
329         if (adapt_layer == NULL) {
330                 pr_debug("link setup response but no client exist, send linkdown back\n");
331                 cfctrl_linkdown_req(cnfg->ctrl, channel_id, NULL);
332                 return;
333         }
334
335         caif_assert(cnfg != NULL);
336         caif_assert(phyid != 0);
337         phyinfo = &cnfg->phy_layers[phyid];
338         caif_assert(phyinfo->id == phyid);
339         caif_assert(phyinfo->phy_layer != NULL);
340         caif_assert(phyinfo->phy_layer->id == phyid);
341
342         phyinfo->phy_ref_count++;
343         if (phyinfo->phy_ref_count == 1 &&
344             phyinfo->phy_layer->modemcmd != NULL) {
345                 phyinfo->phy_layer->modemcmd(phyinfo->phy_layer,
346                                              _CAIF_MODEMCMD_PHYIF_USEFULL);
347         }
348         adapt_layer->id = channel_id;
349
350         switch (serv) {
351         case CFCTRL_SRV_VEI:
352                 servicel = cfvei_create(channel_id, &phyinfo->dev_info);
353                 break;
354         case CFCTRL_SRV_DATAGRAM:
355                 servicel = cfdgml_create(channel_id, &phyinfo->dev_info);
356                 break;
357         case CFCTRL_SRV_RFM:
358                 netdev = phyinfo->dev_info.dev;
359                 servicel = cfrfml_create(channel_id, &phyinfo->dev_info,
360                                                 netdev->mtu);
361                 break;
362         case CFCTRL_SRV_UTIL:
363                 servicel = cfutill_create(channel_id, &phyinfo->dev_info);
364                 break;
365         case CFCTRL_SRV_VIDEO:
366                 servicel = cfvidl_create(channel_id, &phyinfo->dev_info);
367                 break;
368         case CFCTRL_SRV_DBG:
369                 servicel = cfdbgl_create(channel_id, &phyinfo->dev_info);
370                 break;
371         default:
372                 pr_err("Protocol error. Link setup response - unknown channel type\n");
373                 return;
374         }
375         if (!servicel) {
376                 pr_warn("Out of memory\n");
377                 return;
378         }
379         layer_set_dn(servicel, cnfg->mux);
380         cfmuxl_set_uplayer(cnfg->mux, servicel, channel_id);
381         layer_set_up(servicel, adapt_layer);
382         layer_set_dn(adapt_layer, servicel);
383         cfsrvl_get(servicel);
384         servicel->ctrlcmd(servicel, CAIF_CTRLCMD_INIT_RSP, 0);
385 }
386
387 void
388 cfcnfg_add_phy_layer(struct cfcnfg *cnfg, enum cfcnfg_phy_type phy_type,
389                      struct net_device *dev, struct cflayer *phy_layer,
390                      u16 *phyid, enum cfcnfg_phy_preference pref,
391                      bool fcs, bool stx)
392 {
393         struct cflayer *frml;
394         struct cflayer *phy_driver = NULL;
395         int i;
396
397
398         if (cnfg->phy_layers[cnfg->last_phyid].frm_layer == NULL) {
399                 *phyid = cnfg->last_phyid;
400
401                 /* range: * 1..(MAX_PHY_LAYERS-1) */
402                 cnfg->last_phyid =
403                     (cnfg->last_phyid % (MAX_PHY_LAYERS - 1)) + 1;
404         } else {
405                 *phyid = 0;
406                 for (i = 1; i < MAX_PHY_LAYERS; i++) {
407                         if (cnfg->phy_layers[i].frm_layer == NULL) {
408                                 *phyid = i;
409                                 break;
410                         }
411                 }
412         }
413         if (*phyid == 0) {
414                 pr_err("No Available PHY ID\n");
415                 return;
416         }
417
418         switch (phy_type) {
419         case CFPHYTYPE_FRAG:
420                 phy_driver =
421                     cfserl_create(CFPHYTYPE_FRAG, *phyid, stx);
422                 if (!phy_driver) {
423                         pr_warn("Out of memory\n");
424                         return;
425                 }
426
427                 break;
428         case CFPHYTYPE_CAIF:
429                 phy_driver = NULL;
430                 break;
431         default:
432                 pr_err("%d\n", phy_type);
433                 return;
434                 break;
435         }
436
437         phy_layer->id = *phyid;
438         cnfg->phy_layers[*phyid].pref = pref;
439         cnfg->phy_layers[*phyid].id = *phyid;
440         cnfg->phy_layers[*phyid].dev_info.id = *phyid;
441         cnfg->phy_layers[*phyid].dev_info.dev = dev;
442         cnfg->phy_layers[*phyid].phy_layer = phy_layer;
443         cnfg->phy_layers[*phyid].phy_ref_count = 0;
444         cnfg->phy_layers[*phyid].ifindex = dev->ifindex;
445         cnfg->phy_layers[*phyid].use_stx = stx;
446         cnfg->phy_layers[*phyid].use_fcs = fcs;
447
448         phy_layer->type = phy_type;
449         frml = cffrml_create(*phyid, fcs);
450         if (!frml) {
451                 pr_warn("Out of memory\n");
452                 return;
453         }
454         cnfg->phy_layers[*phyid].frm_layer = frml;
455         cfmuxl_set_dnlayer(cnfg->mux, frml, *phyid);
456         layer_set_up(frml, cnfg->mux);
457
458         if (phy_driver != NULL) {
459                 phy_driver->id = *phyid;
460                 layer_set_dn(frml, phy_driver);
461                 layer_set_up(phy_driver, frml);
462                 layer_set_dn(phy_driver, phy_layer);
463                 layer_set_up(phy_layer, phy_driver);
464         } else {
465                 layer_set_dn(frml, phy_layer);
466                 layer_set_up(phy_layer, frml);
467         }
468 }
469 EXPORT_SYMBOL(cfcnfg_add_phy_layer);
470
471 int cfcnfg_del_phy_layer(struct cfcnfg *cnfg, struct cflayer *phy_layer)
472 {
473         struct cflayer *frml, *frml_dn;
474         u16 phyid;
475         phyid = phy_layer->id;
476         caif_assert(phyid == cnfg->phy_layers[phyid].id);
477         caif_assert(phy_layer == cnfg->phy_layers[phyid].phy_layer);
478         caif_assert(phy_layer->id == phyid);
479         caif_assert(cnfg->phy_layers[phyid].frm_layer->id == phyid);
480
481         memset(&cnfg->phy_layers[phy_layer->id], 0,
482                sizeof(struct cfcnfg_phyinfo));
483         frml = cfmuxl_remove_dnlayer(cnfg->mux, phy_layer->id);
484         frml_dn = frml->dn;
485         cffrml_set_uplayer(frml, NULL);
486         cffrml_set_dnlayer(frml, NULL);
487         kfree(frml);
488
489         if (phy_layer != frml_dn) {
490                 layer_set_up(frml_dn, NULL);
491                 layer_set_dn(frml_dn, NULL);
492                 kfree(frml_dn);
493         }
494         layer_set_up(phy_layer, NULL);
495         return 0;
496 }
497 EXPORT_SYMBOL(cfcnfg_del_phy_layer);