This source file includes following definitions.
- profi_read_area
- profi_write_area
- profi_id_get
- profi_enable_get
- __profi_enable
- __profi_disable
- profi_simple_enable
- profi_on_area_updated
- profi_on_online_changed
- profinet_probe
- profinet_remove
- profinet_init
- profinet_exit
1
2
3
4
5
6
7
8 #include <linux/kernel.h>
9 #include <linux/module.h>
10 #include <linux/init.h>
11 #include <linux/slab.h>
12
13
14 #include "../fieldbus_dev.h"
15
16
17 #include "anybuss-client.h"
18
19 #define PROFI_DPRAM_SIZE 512
20
21
22
23
24
25
26
27
28
29 struct msg_mac_addr {
30 u8 addr[6];
31 };
32
33 struct profi_priv {
34 struct fieldbus_dev fbdev;
35 struct anybuss_client *client;
36 struct mutex enable_lock;
37 bool power_on;
38 };
39
40 static ssize_t
41 profi_read_area(struct fieldbus_dev *fbdev, char __user *buf, size_t size,
42 loff_t *offset)
43 {
44 struct profi_priv *priv = container_of(fbdev, struct profi_priv, fbdev);
45
46 return anybuss_read_output(priv->client, buf, size, offset);
47 }
48
49 static ssize_t
50 profi_write_area(struct fieldbus_dev *fbdev, const char __user *buf,
51 size_t size, loff_t *offset)
52 {
53 struct profi_priv *priv = container_of(fbdev, struct profi_priv, fbdev);
54
55 return anybuss_write_input(priv->client, buf, size, offset);
56 }
57
58 static int profi_id_get(struct fieldbus_dev *fbdev, char *buf,
59 size_t max_size)
60 {
61 struct profi_priv *priv = container_of(fbdev, struct profi_priv, fbdev);
62 struct msg_mac_addr response;
63 int ret;
64
65 ret = anybuss_recv_msg(priv->client, 0x0010, &response,
66 sizeof(response));
67 if (ret < 0)
68 return ret;
69 return snprintf(buf, max_size, "%02X:%02X:%02X:%02X:%02X:%02X\n",
70 response.addr[0], response.addr[1],
71 response.addr[2], response.addr[3],
72 response.addr[4], response.addr[5]);
73 }
74
75 static bool profi_enable_get(struct fieldbus_dev *fbdev)
76 {
77 struct profi_priv *priv = container_of(fbdev, struct profi_priv, fbdev);
78 bool power_on;
79
80 mutex_lock(&priv->enable_lock);
81 power_on = priv->power_on;
82 mutex_unlock(&priv->enable_lock);
83
84 return power_on;
85 }
86
87 static int __profi_enable(struct profi_priv *priv)
88 {
89 int ret;
90 struct anybuss_client *client = priv->client;
91
92 const struct anybuss_memcfg mem_cfg = {
93 .input_io = 220,
94 .input_dpram = PROFI_DPRAM_SIZE,
95 .input_total = PROFI_DPRAM_SIZE,
96 .output_io = 220,
97 .output_dpram = PROFI_DPRAM_SIZE,
98 .output_total = PROFI_DPRAM_SIZE,
99 .offl_mode = AB_OFFL_MODE_CLEAR,
100 };
101
102
103
104
105
106 anybuss_set_power(client, false);
107 ret = anybuss_set_power(client, true);
108 if (ret)
109 goto err;
110 ret = anybuss_start_init(client, &mem_cfg);
111 if (ret)
112 goto err;
113 ret = anybuss_finish_init(client);
114 if (ret)
115 goto err;
116 priv->power_on = true;
117 return 0;
118
119 err:
120 anybuss_set_power(client, false);
121 priv->power_on = false;
122 return ret;
123 }
124
125 static int __profi_disable(struct profi_priv *priv)
126 {
127 struct anybuss_client *client = priv->client;
128
129 anybuss_set_power(client, false);
130 priv->power_on = false;
131 return 0;
132 }
133
134 static int profi_simple_enable(struct fieldbus_dev *fbdev, bool enable)
135 {
136 int ret;
137 struct profi_priv *priv = container_of(fbdev, struct profi_priv, fbdev);
138
139 mutex_lock(&priv->enable_lock);
140 if (enable)
141 ret = __profi_enable(priv);
142 else
143 ret = __profi_disable(priv);
144 mutex_unlock(&priv->enable_lock);
145
146 return ret;
147 }
148
149 static void profi_on_area_updated(struct anybuss_client *client)
150 {
151 struct profi_priv *priv = anybuss_get_drvdata(client);
152
153 fieldbus_dev_area_updated(&priv->fbdev);
154 }
155
156 static void profi_on_online_changed(struct anybuss_client *client, bool online)
157 {
158 struct profi_priv *priv = anybuss_get_drvdata(client);
159
160 fieldbus_dev_online_changed(&priv->fbdev, online);
161 }
162
163 static int profinet_probe(struct anybuss_client *client)
164 {
165 struct profi_priv *priv;
166 struct device *dev = &client->dev;
167 int err;
168
169 client->on_area_updated = profi_on_area_updated;
170 client->on_online_changed = profi_on_online_changed;
171 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
172 if (!priv)
173 return -ENOMEM;
174 mutex_init(&priv->enable_lock);
175 priv->client = client;
176 priv->fbdev.read_area_sz = PROFI_DPRAM_SIZE;
177 priv->fbdev.write_area_sz = PROFI_DPRAM_SIZE;
178 priv->fbdev.card_name = "HMS Profinet IRT (Anybus-S)";
179 priv->fbdev.fieldbus_type = FIELDBUS_DEV_TYPE_PROFINET;
180 priv->fbdev.read_area = profi_read_area;
181 priv->fbdev.write_area = profi_write_area;
182 priv->fbdev.fieldbus_id_get = profi_id_get;
183 priv->fbdev.enable_get = profi_enable_get;
184 priv->fbdev.simple_enable_set = profi_simple_enable;
185 priv->fbdev.parent = dev;
186 err = fieldbus_dev_register(&priv->fbdev);
187 if (err < 0)
188 return err;
189 dev_info(dev, "card detected, registered as %s",
190 dev_name(priv->fbdev.dev));
191 anybuss_set_drvdata(client, priv);
192
193 return 0;
194 }
195
196 static int profinet_remove(struct anybuss_client *client)
197 {
198 struct profi_priv *priv = anybuss_get_drvdata(client);
199
200 fieldbus_dev_unregister(&priv->fbdev);
201 return 0;
202 }
203
204 static struct anybuss_client_driver profinet_driver = {
205 .probe = profinet_probe,
206 .remove = profinet_remove,
207 .driver = {
208 .name = "hms-profinet",
209 .owner = THIS_MODULE,
210 },
211 .anybus_id = 0x0089,
212 };
213
214 static int __init profinet_init(void)
215 {
216 return anybuss_client_driver_register(&profinet_driver);
217 }
218 module_init(profinet_init);
219
220 static void __exit profinet_exit(void)
221 {
222 return anybuss_client_driver_unregister(&profinet_driver);
223 }
224 module_exit(profinet_exit);
225
226 MODULE_AUTHOR("Sven Van Asbroeck <TheSven73@gmail.com>");
227 MODULE_DESCRIPTION("HMS Profinet IRT Driver (Anybus-S)");
228 MODULE_LICENSE("GPL v2");