tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
crypto: engine - replace pr_xxx by dev_xxx
By adding a struct device *dev to struct engine, we could store the
device used at register time and so use all dev_xxx functions instead of
pr_xxx.
Signed-off-by: Corentin Labbe <clabbe.montjoie@gmail.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
authored by
Corentin LABBE
and committed by
Herbert Xu
88d58ef8
cf3f9609
+14
-10
+13
-10
crypto/crypto_engine.c
+13
-10
crypto/crypto_engine.c
···
70
70
71
71
if (engine->unprepare_crypt_hardware &&
72
72
engine->unprepare_crypt_hardware(engine))
73
-
pr_err("failed to unprepare crypt hardware\n");
73
+
dev_err(engine->dev, "failed to unprepare crypt hardware\n");
74
74
75
75
spin_lock_irqsave(&engine->queue_lock, flags);
76
76
engine->idling = false;
···
99
99
if (!was_busy && engine->prepare_crypt_hardware) {
100
100
ret = engine->prepare_crypt_hardware(engine);
101
101
if (ret) {
102
-
pr_err("failed to prepare crypt hardware\n");
102
+
dev_err(engine->dev, "failed to prepare crypt hardware\n");
103
103
goto req_err;
104
104
}
105
105
}
···
110
110
if (engine->prepare_hash_request) {
111
111
ret = engine->prepare_hash_request(engine, hreq);
112
112
if (ret) {
113
-
pr_err("failed to prepare request: %d\n", ret);
113
+
dev_err(engine->dev, "failed to prepare request: %d\n",
114
+
ret);
114
115
goto req_err;
115
116
}
116
117
engine->cur_req_prepared = true;
117
118
}
118
119
ret = engine->hash_one_request(engine, hreq);
119
120
if (ret) {
120
-
pr_err("failed to hash one request from queue\n");
121
+
dev_err(engine->dev, "failed to hash one request from queue\n");
121
122
goto req_err;
122
123
}
123
124
return;
···
127
126
if (engine->prepare_cipher_request) {
128
127
ret = engine->prepare_cipher_request(engine, breq);
129
128
if (ret) {
130
-
pr_err("failed to prepare request: %d\n", ret);
129
+
dev_err(engine->dev, "failed to prepare request: %d\n",
130
+
ret);
131
131
goto req_err;
132
132
}
133
133
engine->cur_req_prepared = true;
134
134
}
135
135
ret = engine->cipher_one_request(engine, breq);
136
136
if (ret) {
137
-
pr_err("failed to cipher one request from queue\n");
137
+
dev_err(engine->dev, "failed to cipher one request from queue\n");
138
138
goto req_err;
139
139
}
140
140
return;
141
141
default:
142
-
pr_err("failed to prepare request of unknown type\n");
142
+
dev_err(engine->dev, "failed to prepare request of unknown type\n");
143
143
return;
144
144
}
145
145
···
277
275
engine->unprepare_cipher_request) {
278
276
ret = engine->unprepare_cipher_request(engine, req);
279
277
if (ret)
280
-
pr_err("failed to unprepare request\n");
278
+
dev_err(engine->dev, "failed to unprepare request\n");
281
279
}
282
280
spin_lock_irqsave(&engine->queue_lock, flags);
283
281
engine->cur_req = NULL;
···
314
312
engine->unprepare_hash_request) {
315
313
ret = engine->unprepare_hash_request(engine, req);
316
314
if (ret)
317
-
pr_err("failed to unprepare request\n");
315
+
dev_err(engine->dev, "failed to unprepare request\n");
318
316
}
319
317
spin_lock_irqsave(&engine->queue_lock, flags);
320
318
engine->cur_req = NULL;
···
386
384
spin_unlock_irqrestore(&engine->queue_lock, flags);
387
385
388
386
if (ret)
389
-
pr_warn("could not stop engine\n");
387
+
dev_warn(engine->dev, "could not stop engine\n");
390
388
391
389
return ret;
392
390
}
···
413
411
if (!engine)
414
412
return NULL;
415
413
414
+
engine->dev = dev;
416
415
engine->rt = rt;
417
416
engine->running = false;
418
417
engine->busy = false;